src/mesa/state_tracker/st_format.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28
  29 /**
  30  * Texture Image-related functions.
  31  * \author Brian Paul
  32  */
  33
  34 #include "main/imports.h"
  35 #include "main/context.h"
  36 #include "main/texstore.h"
  37 #include "main/texformat.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 "st_context.h"
  45 #include "st_format.h"
  46
  47 static GLuint
  48 format_bits(
  49    pipe_format_rgbazs_t  info,
  50    GLuint comp )
  51 {
  52    return pf_get_component_bits( (enum pipe_format) info, comp );
  53 }
  54
  55 static GLuint
  56 format_max_bits(
  57    pipe_format_rgbazs_t  info )
  58 {
  59    GLuint   size = format_bits( info, PIPE_FORMAT_COMP_R );
  60
  61    size = MAX2( size, format_bits( info, PIPE_FORMAT_COMP_G ) );
  62    size = MAX2( size, format_bits( info, PIPE_FORMAT_COMP_B ) );
  63    size = MAX2( size, format_bits( info, PIPE_FORMAT_COMP_A ) );
  64    size = MAX2( size, format_bits( info, PIPE_FORMAT_COMP_Z ) );
  65    size = MAX2( size, format_bits( info, PIPE_FORMAT_COMP_S ) );
  66    return size;
  67 }
  68
  69 static GLuint
  70 format_size(
  71    pipe_format_rgbazs_t  info )
  72 {
  73    return
  74       format_bits( info, PIPE_FORMAT_COMP_R ) +
  75       format_bits( info, PIPE_FORMAT_COMP_G ) +
  76       format_bits( info, PIPE_FORMAT_COMP_B ) +
  77       format_bits( info, PIPE_FORMAT_COMP_A ) +
  78       format_bits( info, PIPE_FORMAT_COMP_Z ) +
  79       format_bits( info, PIPE_FORMAT_COMP_S );
  80 }
  81
  82 /*
  83  * XXX temporary here
  84  */
  85 GLboolean
  86 st_get_format_info(enum pipe_format format, struct pipe_format_info *pinfo)
  87 {
  88    if (pf_layout(format) == PIPE_FORMAT_LAYOUT_RGBAZS) {
  89       pipe_format_rgbazs_t info;
  90
  91       info = format;
  92
  93 #if 0
  94       printf("%s\n", pf_name( format ) );
  95 #endif
  96
  97       /* Data type */
  98       if (format == PIPE_FORMAT_A1R5G5B5_UNORM || format == PIPE_FORMAT_R5G6B5_UNORM) {
  99          pinfo->datatype = GL_UNSIGNED_SHORT;
 100       }
 101       else {
 102          GLuint size;
 103
 104          size = format_max_bits( info );
 105          if (size == 8) {
 106             if (pf_type(info) == PIPE_FORMAT_TYPE_UNORM)
 107                pinfo->datatype = GL_UNSIGNED_BYTE;
 108             else
 109                pinfo->datatype = GL_BYTE;
 110          }
 111          else if (size == 16) {
 112             if (pf_type(info) == PIPE_FORMAT_TYPE_UNORM)
 113                pinfo->datatype = GL_UNSIGNED_SHORT;
 114             else
 115                pinfo->datatype = GL_SHORT;
 116          }
 117          else {
 118             assert( size <= 32 );
 119             if (pf_type(info) == PIPE_FORMAT_TYPE_UNORM)
 120                pinfo->datatype = GL_UNSIGNED_INT;
 121             else
 122                pinfo->datatype = GL_INT;
 123          }
 124       }
 125
 126       /* Component bits */
 127       pinfo->red_bits = format_bits( info, PIPE_FORMAT_COMP_R );
 128       pinfo->green_bits = format_bits( info, PIPE_FORMAT_COMP_G );
 129       pinfo->blue_bits = format_bits( info, PIPE_FORMAT_COMP_B );
 130       pinfo->alpha_bits = format_bits( info, PIPE_FORMAT_COMP_A );
 131       pinfo->depth_bits = format_bits( info, PIPE_FORMAT_COMP_Z );
 132       pinfo->stencil_bits = format_bits( info, PIPE_FORMAT_COMP_S );
 133       pinfo->luminance_bits = 0;
 134       pinfo->intensity_bits = 0;
 135
 136       /* Format size */
 137       pinfo->size = format_size( info ) / 8;
 138
 139       /* Luminance & Intensity bits */
 140       if( pf_swizzle_x(info) == PIPE_FORMAT_COMP_R &&
 141           pf_swizzle_y(info) == PIPE_FORMAT_COMP_R &&
 142           pf_swizzle_z(info) == PIPE_FORMAT_COMP_R ) {
 143          if( pf_swizzle_w(info) == PIPE_FORMAT_COMP_R ) {
 144             pinfo->intensity_bits = pinfo->red_bits;
 145          }
 146          else {
 147             pinfo->luminance_bits = pinfo->red_bits;
 148          }
 149          pinfo->red_bits = 0;
 150       }
 151
 152       /* Base format */
 153       if (pinfo->depth_bits) {
 154          if (pinfo->stencil_bits) {
 155             pinfo->base_format = GL_DEPTH_STENCIL_EXT;
 156          }
 157          else {
 158             pinfo->base_format = GL_DEPTH_COMPONENT;
 159          }
 160       }
 161       else if (pinfo->stencil_bits) {
 162          pinfo->base_format = GL_STENCIL_INDEX;
 163       }
 164       else {
 165          pinfo->base_format = GL_RGBA;
 166       }
 167    }
 168    else if (pf_layout(format) == PIPE_FORMAT_LAYOUT_YCBCR) {
 169       pinfo->base_format = GL_YCBCR_MESA;
 170       pinfo->datatype = GL_UNSIGNED_SHORT;
 171       pinfo->size = 2; /* two bytes per "texel" */
 172    }
 173    else {
 174       /* compressed format? */
 175       assert(0);
 176    }
 177
 178 #if 0
 179    printf(
 180       "ST_FORMAT: R(%u), G(%u), B(%u), A(%u), Z(%u), S(%u)\n",
 181       pinfo->red_bits,
 182       pinfo->green_bits,
 183       pinfo->blue_bits,
 184       pinfo->alpha_bits,
 185       pinfo->depth_bits,
 186       pinfo->stencil_bits );
 187 #endif
 188
 189    pinfo->format = format;
 190
 191    return GL_TRUE;
 192 }
 193
 194
 195 /**
 196  * Return bytes per pixel for the given format.
 197  */
 198 GLuint
 199 st_sizeof_format(enum pipe_format format)
 200 {
 201    struct pipe_format_info info;
 202    if (!st_get_format_info( format, &info )) {
 203       assert( 0 );
 204       return 0;
 205    }
 206    return info.size;
 207 }
 208
 209
 210 /**
 211  * Return bytes per pixel for the given format.
 212  */
 213 GLenum
 214 st_format_datatype(enum pipe_format format)
 215 {
 216    struct pipe_format_info info;
 217    if (!st_get_format_info( format, &info )) {
 218       assert( 0 );
 219       return 0;
 220    }
 221    return info.datatype;
 222 }
 223
 224
 225 enum pipe_format
 226 st_mesa_format_to_pipe_format(GLuint mesaFormat)
 227 {
 228    switch (mesaFormat) {
 229       /* fix this */
 230    case MESA_FORMAT_ARGB8888_REV:
 231    case MESA_FORMAT_ARGB8888:
 232       return PIPE_FORMAT_A8R8G8B8_UNORM;
 233    case MESA_FORMAT_ARGB1555:
 234       return PIPE_FORMAT_A1R5G5B5_UNORM;
 235    case MESA_FORMAT_ARGB4444:
 236       return PIPE_FORMAT_A4R4G4B4_UNORM;
 237    case MESA_FORMAT_RGB565:
 238       return PIPE_FORMAT_R5G6B5_UNORM;
 239    case MESA_FORMAT_AL88:
 240       return PIPE_FORMAT_A8L8_UNORM;
 241    case MESA_FORMAT_A8:
 242       return PIPE_FORMAT_A8_UNORM;
 243    case MESA_FORMAT_L8:
 244       return PIPE_FORMAT_L8_UNORM;
 245    case MESA_FORMAT_I8:
 246       return PIPE_FORMAT_I8_UNORM;
 247    case MESA_FORMAT_Z16:
 248       return PIPE_FORMAT_Z16_UNORM;
 249    case MESA_FORMAT_Z32:
 250       return PIPE_FORMAT_Z32_UNORM;
 251    case MESA_FORMAT_Z24_S8:
 252       return PIPE_FORMAT_Z24S8_UNORM;
 253    case MESA_FORMAT_S8_Z24:
 254       return PIPE_FORMAT_S8Z24_UNORM;
 255    case MESA_FORMAT_YCBCR:
 256       return PIPE_FORMAT_YCBCR;
 257 #if FEATURE_texture_s3tc
 258    case MESA_FORMAT_RGB_DXT1:
 259       return PIPE_FORMAT_DXT1_RGB;
 260    case MESA_FORMAT_RGBA_DXT1:
 261       return PIPE_FORMAT_DXT1_RGBA;
 262    case MESA_FORMAT_RGBA_DXT3:
 263       return PIPE_FORMAT_DXT3_RGBA;
 264    case MESA_FORMAT_RGBA_DXT5:
 265       return PIPE_FORMAT_DXT5_RGBA;
 266 #endif
 267    default:
 268       assert(0);
 269       return 0;
 270    }
 271 }
 272
 273 /**
 274  * Find an RGBA format supported by the context/winsys.
 275  */
 276 static enum pipe_format
 277 default_rgba_format(struct pipe_screen *screen,
 278                     enum pipe_texture_target target,
 279                     unsigned tex_usage,
 280                     unsigned geom_flags)
 281 {
 282    static const enum pipe_format colorFormats[] = {
 283       PIPE_FORMAT_A8R8G8B8_UNORM,
 284       PIPE_FORMAT_B8G8R8A8_UNORM,
 285       PIPE_FORMAT_R8G8B8A8_UNORM,
 286       PIPE_FORMAT_R5G6B5_UNORM
 287    };
 288    uint i;
 289    for (i = 0; i < Elements(colorFormats); i++) {
 290       if (screen->is_format_supported( screen, colorFormats[i], target, tex_usage, geom_flags )) {
 291          return colorFormats[i];
 292       }
 293    }
 294    return PIPE_FORMAT_NONE;
 295 }
 296
 297
 298 /**
 299  * Search list of formats for first RGBA format with >8 bits/channel.
 300  */
 301 static enum pipe_format
 302 default_deep_rgba_format(struct pipe_screen *screen,
 303                          enum pipe_texture_target target,
 304                          unsigned tex_usage,
 305                          unsigned geom_flags)
 306 {
 307    if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_SNORM, target, tex_usage, geom_flags)) {
 308       return PIPE_FORMAT_R16G16B16A16_SNORM;
 309    }
 310    if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET)
 311       return default_rgba_format(screen, target, tex_usage, geom_flags);
 312    else
 313       return PIPE_FORMAT_NONE;
 314 }
 315
 316
 317 /**
 318  * Find an Z format supported by the context/winsys.
 319  */
 320 static enum pipe_format
 321 default_depth_format(struct pipe_screen *screen,
 322                      enum pipe_texture_target target,
 323                      unsigned tex_usage,
 324                      unsigned geom_flags)
 325 {
 326    static const enum pipe_format zFormats[] = {
 327       PIPE_FORMAT_Z16_UNORM,
 328       PIPE_FORMAT_Z32_UNORM,
 329       PIPE_FORMAT_S8Z24_UNORM,
 330       PIPE_FORMAT_Z24S8_UNORM
 331    };
 332    uint i;
 333    for (i = 0; i < Elements(zFormats); i++) {
 334       if (screen->is_format_supported( screen, zFormats[i], target, tex_usage, geom_flags )) {
 335          return zFormats[i];
 336       }
 337    }
 338    return PIPE_FORMAT_NONE;
 339 }
 340
 341
 342 /**
 343  * Given an OpenGL internalFormat value for a texture or surface, return
 344  * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.
 345  * \param target  one of PIPE_TEXTURE_x
 346  * \param tex_usage  either PIPE_TEXTURE_USAGE_RENDER_TARGET
 347  *                   or PIPE_TEXTURE_USAGE_SAMPLER
 348  */
 349 enum pipe_format
 350 st_choose_format(struct pipe_context *pipe, GLint internalFormat,
 351                  enum pipe_texture_target target, unsigned tex_usage)
 352 {
 353    struct pipe_screen *screen = pipe->screen;
 354    unsigned geom_flags = 0;
 355
 356    switch (internalFormat) {
 357    case 4:
 358    case GL_RGBA:
 359    case GL_COMPRESSED_RGBA:
 360    case 3:
 361    case GL_RGB:
 362    case GL_COMPRESSED_RGB:
 363    case GL_RGBA8:
 364    case GL_RGB10_A2:
 365    case GL_RGBA12:
 366       return default_rgba_format( screen, target, tex_usage, geom_flags );
 367    case GL_RGBA16:
 368       if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET)
 369          return default_deep_rgba_format( screen, target, tex_usage, geom_flags );
 370       else
 371          return default_rgba_format( screen, target, tex_usage, geom_flags );
 372
 373    case GL_RGBA4:
 374    case GL_RGBA2:
 375       if (screen->is_format_supported( screen, PIPE_FORMAT_A4R4G4B4_UNORM, target, tex_usage, geom_flags ))
 376          return PIPE_FORMAT_A4R4G4B4_UNORM;
 377       return default_rgba_format( screen, target, tex_usage, geom_flags );
 378
 379    case GL_RGB5_A1:
 380       if (screen->is_format_supported( screen, PIPE_FORMAT_A1R5G5B5_UNORM, target, tex_usage, geom_flags ))
 381          return PIPE_FORMAT_A1R5G5B5_UNORM;
 382       return default_rgba_format( screen, target, tex_usage, geom_flags );
 383
 384    case GL_RGB8:
 385    case GL_RGB10:
 386    case GL_RGB12:
 387    case GL_RGB16:
 388       return default_rgba_format( screen, target, tex_usage, geom_flags );
 389
 390    case GL_RGB5:
 391    case GL_RGB4:
 392    case GL_R3_G3_B2:
 393       if (screen->is_format_supported( screen, PIPE_FORMAT_A1R5G5B5_UNORM, target, tex_usage, geom_flags ))
 394          return PIPE_FORMAT_A1R5G5B5_UNORM;
 395       if (screen->is_format_supported( screen, PIPE_FORMAT_R5G6B5_UNORM, target, tex_usage, geom_flags ))
 396          return PIPE_FORMAT_R5G6B5_UNORM;
 397       return default_rgba_format( screen, target, tex_usage, geom_flags );
 398
 399    case GL_ALPHA:
 400    case GL_ALPHA4:
 401    case GL_ALPHA8:
 402    case GL_ALPHA12:
 403    case GL_ALPHA16:
 404    case GL_COMPRESSED_ALPHA:
 405       if (screen->is_format_supported( screen, PIPE_FORMAT_A8_UNORM, target, tex_usage, geom_flags ))
 406          return PIPE_FORMAT_A8_UNORM;
 407       return default_rgba_format( screen, target, tex_usage, geom_flags );
 408
 409    case 1:
 410    case GL_LUMINANCE:
 411    case GL_LUMINANCE4:
 412    case GL_LUMINANCE8:
 413    case GL_LUMINANCE12:
 414    case GL_LUMINANCE16:
 415    case GL_COMPRESSED_LUMINANCE:
 416       if (screen->is_format_supported( screen, PIPE_FORMAT_L8_UNORM, target, tex_usage, geom_flags ))
 417          return PIPE_FORMAT_L8_UNORM;
 418       return default_rgba_format( screen, target, tex_usage, geom_flags );
 419
 420    case 2:
 421    case GL_LUMINANCE_ALPHA:
 422    case GL_LUMINANCE4_ALPHA4:
 423    case GL_LUMINANCE6_ALPHA2:
 424    case GL_LUMINANCE8_ALPHA8:
 425    case GL_LUMINANCE12_ALPHA4:
 426    case GL_LUMINANCE12_ALPHA12:
 427    case GL_LUMINANCE16_ALPHA16:
 428    case GL_COMPRESSED_LUMINANCE_ALPHA:
 429       if (screen->is_format_supported( screen, PIPE_FORMAT_A8L8_UNORM, target, tex_usage, geom_flags ))
 430          return PIPE_FORMAT_A8L8_UNORM;
 431       return default_rgba_format( screen, target, tex_usage, geom_flags );
 432
 433    case GL_INTENSITY:
 434    case GL_INTENSITY4:
 435    case GL_INTENSITY8:
 436    case GL_INTENSITY12:
 437    case GL_INTENSITY16:
 438    case GL_COMPRESSED_INTENSITY:
 439       if (screen->is_format_supported( screen, PIPE_FORMAT_I8_UNORM, target, tex_usage, geom_flags ))
 440          return PIPE_FORMAT_I8_UNORM;
 441       return default_rgba_format( screen, target, tex_usage, geom_flags );
 442
 443    case GL_YCBCR_MESA:
 444       if (screen->is_format_supported(screen, PIPE_FORMAT_YCBCR,
 445                                       target, tex_usage, geom_flags)) {
 446          return PIPE_FORMAT_YCBCR;
 447       }
 448       if (screen->is_format_supported(screen, PIPE_FORMAT_YCBCR_REV,
 449                                       target, tex_usage, geom_flags)) {
 450          return PIPE_FORMAT_YCBCR_REV;
 451       }
 452       return PIPE_FORMAT_NONE;
 453
 454    case GL_RGB_S3TC:
 455    case GL_RGB4_S3TC:
 456    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
 457       return PIPE_FORMAT_DXT1_RGB;
 458
 459    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
 460       return PIPE_FORMAT_DXT1_RGBA;
 461
 462    case GL_RGBA_S3TC:
 463    case GL_RGBA4_S3TC:
 464    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
 465       return PIPE_FORMAT_DXT3_RGBA;
 466
 467    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
 468       return PIPE_FORMAT_DXT5_RGBA;
 469
 470 #if 0
 471    case GL_COMPRESSED_RGB_FXT1_3DFX:
 472       return PIPE_FORMAT_RGB_FXT1;
 473    case GL_COMPRESSED_RGBA_FXT1_3DFX:
 474       return PIPE_FORMAT_RGB_FXT1;
 475 #endif
 476
 477    case GL_DEPTH_COMPONENT16:
 478       if (screen->is_format_supported( screen, PIPE_FORMAT_Z16_UNORM, target, tex_usage, geom_flags ))
 479          return PIPE_FORMAT_Z16_UNORM;
 480       /* fall-through */
 481    case GL_DEPTH_COMPONENT24:
 482       if (screen->is_format_supported( screen, PIPE_FORMAT_S8Z24_UNORM, target, tex_usage, geom_flags ))
 483          return PIPE_FORMAT_S8Z24_UNORM;
 484       if (screen->is_format_supported( screen, PIPE_FORMAT_Z24S8_UNORM, target, tex_usage, geom_flags ))
 485          return PIPE_FORMAT_Z24S8_UNORM;
 486       /* fall-through */
 487    case GL_DEPTH_COMPONENT32:
 488       if (screen->is_format_supported( screen, PIPE_FORMAT_Z32_UNORM, target, tex_usage, geom_flags ))
 489          return PIPE_FORMAT_Z32_UNORM;
 490       /* fall-through */
 491    case GL_DEPTH_COMPONENT:
 492       return default_depth_format( screen, target, tex_usage, geom_flags );
 493
 494    case GL_STENCIL_INDEX:
 495    case GL_STENCIL_INDEX1_EXT:
 496    case GL_STENCIL_INDEX4_EXT:
 497    case GL_STENCIL_INDEX8_EXT:
 498    case GL_STENCIL_INDEX16_EXT:
 499       if (screen->is_format_supported( screen, PIPE_FORMAT_S8_UNORM, target, tex_usage, geom_flags ))
 500          return PIPE_FORMAT_S8_UNORM;
 501       if (screen->is_format_supported( screen, PIPE_FORMAT_S8Z24_UNORM, target, tex_usage, geom_flags ))
 502          return PIPE_FORMAT_S8Z24_UNORM;
 503       if (screen->is_format_supported( screen, PIPE_FORMAT_Z24S8_UNORM, target, tex_usage, geom_flags ))
 504          return PIPE_FORMAT_Z24S8_UNORM;
 505       return PIPE_FORMAT_NONE;
 506
 507    case GL_DEPTH_STENCIL_EXT:
 508    case GL_DEPTH24_STENCIL8_EXT:
 509       if (screen->is_format_supported( screen, PIPE_FORMAT_S8Z24_UNORM, target, tex_usage, geom_flags ))
 510          return PIPE_FORMAT_S8Z24_UNORM;
 511       if (screen->is_format_supported( screen, PIPE_FORMAT_Z24S8_UNORM, target, tex_usage, geom_flags ))
 512          return PIPE_FORMAT_Z24S8_UNORM;
 513       return PIPE_FORMAT_NONE;
 514
 515    default:
 516       return PIPE_FORMAT_NONE;
 517    }
 518 }
 519
 520
 521 static GLboolean
 522 is_stencil_format(GLenum format)
 523 {
 524    switch (format) {
 525    case GL_STENCIL_INDEX:
 526    case GL_STENCIL_INDEX1_EXT:
 527    case GL_STENCIL_INDEX4_EXT:
 528    case GL_STENCIL_INDEX8_EXT:
 529    case GL_STENCIL_INDEX16_EXT:
 530    case GL_DEPTH_STENCIL_EXT:
 531    case GL_DEPTH24_STENCIL8_EXT:
 532       return GL_TRUE;
 533    default:
 534       return GL_FALSE;
 535    }
 536 }
 537
 538 /**
 539  * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
 540  */
 541 enum pipe_format
 542 st_choose_renderbuffer_format(struct pipe_context *pipe, GLint internalFormat)
 543 {
 544    uint usage;
 545    if (is_stencil_format(internalFormat))
 546       usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
 547    else
 548       usage = PIPE_TEXTURE_USAGE_RENDER_TARGET;
 549    return st_choose_format(pipe, internalFormat, PIPE_TEXTURE_2D, usage);
 550 }
 551
 552
 553 static const struct gl_texture_format *
 554 translate_gallium_format_to_mesa_format(enum pipe_format format)
 555 {
 556    switch (format) {
 557    case PIPE_FORMAT_A8R8G8B8_UNORM:
 558       return &_mesa_texformat_argb8888;
 559    case PIPE_FORMAT_A1R5G5B5_UNORM:
 560       return &_mesa_texformat_argb1555;
 561    case PIPE_FORMAT_A4R4G4B4_UNORM:
 562       return &_mesa_texformat_argb4444;
 563    case PIPE_FORMAT_R5G6B5_UNORM:
 564       return &_mesa_texformat_rgb565;
 565    case PIPE_FORMAT_A8L8_UNORM:
 566       return &_mesa_texformat_al88;
 567    case PIPE_FORMAT_A8_UNORM:
 568       return &_mesa_texformat_a8;
 569    case PIPE_FORMAT_L8_UNORM:
 570       return &_mesa_texformat_l8;
 571    case PIPE_FORMAT_I8_UNORM:
 572       return &_mesa_texformat_i8;
 573    case PIPE_FORMAT_Z16_UNORM:
 574       return &_mesa_texformat_z16;
 575    case PIPE_FORMAT_Z32_UNORM:
 576       return &_mesa_texformat_z32;
 577    case PIPE_FORMAT_Z24S8_UNORM:
 578       return &_mesa_texformat_z24_s8;
 579    case PIPE_FORMAT_S8Z24_UNORM:
 580       return &_mesa_texformat_s8_z24;
 581    case PIPE_FORMAT_YCBCR:
 582       return &_mesa_texformat_ycbcr;
 583    case PIPE_FORMAT_YCBCR_REV:
 584       return &_mesa_texformat_ycbcr_rev;
 585 #if FEATURE_texture_s3tc
 586    case PIPE_FORMAT_DXT1_RGB:
 587       return &_mesa_texformat_rgb_dxt1;
 588    case PIPE_FORMAT_DXT1_RGBA:
 589       return &_mesa_texformat_rgba_dxt1;
 590    case PIPE_FORMAT_DXT3_RGBA:
 591       return &_mesa_texformat_rgba_dxt3;
 592    case PIPE_FORMAT_DXT5_RGBA:
 593       return &_mesa_texformat_rgba_dxt5;
 594 #endif
 595    /* XXX add additional cases */
 596    default:
 597       assert(0);
 598       return NULL;
 599    }
 600 }
 601
 602
 603 /**
 604  * Called via ctx->Driver.chooseTextureFormat().
 605  */
 606 const struct gl_texture_format *
 607 st_ChooseTextureFormat(GLcontext *ctx, GLint internalFormat,
 608                        GLenum format, GLenum type)
 609 {
 610    enum pipe_format pFormat;
 611
 612    (void) format;
 613    (void) type;
 614
 615    pFormat = st_choose_format(ctx->st->pipe, internalFormat, PIPE_TEXTURE_2D,
 616                               PIPE_TEXTURE_USAGE_SAMPLER);
 617    if (pFormat == PIPE_FORMAT_NONE)
 618       return NULL;
 619
 620    return translate_gallium_format_to_mesa_format(pFormat);
 621 }