src/mesa/main/texstorage.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 2011  VMware, Inc.  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 "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  20  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  */
  23
  24
  25 /**
  26  * \file texstorage.c
  27  * GL_ARB_texture_storage functions
  28  */
  29
  30
  31
  32 #include "glheader.h"
  33 #include "context.h"
  34 #include "enums.h"
  35 #include "imports.h"
  36 #include "macros.h"
  37 #include "mfeatures.h"
  38 #include "teximage.h"
  39 #include "texobj.h"
  40 #include "texstorage.h"
  41 #include "mtypes.h"
  42
  43
  44
  45 /**
  46  * Check if the given texture target is a legal texture object target
  47  * for a glTexStorage() command.
  48  * This is a bit different than legal_teximage_target() when it comes
  49  * to cube maps.
  50  */
  51 static GLboolean
  52 legal_texobj_target(struct gl_context *ctx, GLuint dims, GLenum target)
  53 {
  54    switch (dims) {
  55    case 1:
  56       switch (target) {
  57       case GL_TEXTURE_1D:
  58       case GL_PROXY_TEXTURE_1D:
  59          return GL_TRUE;
  60       default:
  61          return GL_FALSE;
  62       }
  63    case 2:
  64       switch (target) {
  65       case GL_TEXTURE_2D:
  66       case GL_PROXY_TEXTURE_2D:
  67          return GL_TRUE;
  68       case GL_TEXTURE_CUBE_MAP:
  69       case GL_PROXY_TEXTURE_CUBE_MAP:
  70          return ctx->Extensions.ARB_texture_cube_map;
  71       case GL_TEXTURE_RECTANGLE:
  72       case GL_PROXY_TEXTURE_RECTANGLE:
  73          return ctx->Extensions.NV_texture_rectangle;
  74       case GL_TEXTURE_1D_ARRAY:
  75       case GL_PROXY_TEXTURE_1D_ARRAY:
  76          return (ctx->Extensions.MESA_texture_array ||
  77                  ctx->Extensions.EXT_texture_array);
  78       default:
  79          return GL_FALSE;
  80       }
  81    case 3:
  82       switch (target) {
  83       case GL_TEXTURE_3D:
  84       case GL_PROXY_TEXTURE_3D:
  85          return GL_TRUE;
  86       case GL_TEXTURE_2D_ARRAY:
  87       case GL_PROXY_TEXTURE_2D_ARRAY:
  88          return (ctx->Extensions.MESA_texture_array ||
  89                  ctx->Extensions.EXT_texture_array);
  90       case GL_TEXTURE_CUBE_MAP_ARRAY:
  91       case GL_PROXY_TEXTURE_CUBE_MAP_ARRAY:
  92          return ctx->Extensions.ARB_texture_cube_map_array;
  93       default:
  94          return GL_FALSE;
  95       }
  96    default:
  97       _mesa_problem(ctx, "invalid dims=%u in legal_texobj_target()", dims);
  98       return GL_FALSE;
  99    }
 100 }
 101
 102
 103 /**
 104  * Compute the size of the next mipmap level.
 105  */
 106 static void
 107 next_mipmap_level_size(GLenum target,
 108                        GLint *width, GLint *height, GLint *depth)
 109 {
 110    if (*width > 1) {
 111       *width /= 2;
 112    }
 113
 114    if ((*height > 1) && (target != GL_TEXTURE_1D_ARRAY)) {
 115       *height /= 2;
 116    }
 117
 118    if ((*depth > 1) && (target != GL_TEXTURE_2D_ARRAY)) {
 119       *depth /= 2;
 120    }
 121 }
 122
 123
 124 /** Helper to get a particular texture image in a texture object */
 125 static struct gl_texture_image *
 126 get_tex_image(struct gl_context *ctx,
 127               struct gl_texture_object *texObj,
 128               GLuint face, GLuint level)
 129 {
 130    const GLenum faceTarget =
 131       (texObj->Target == GL_TEXTURE_CUBE_MAP ||
 132        texObj->Target == GL_PROXY_TEXTURE_CUBE_MAP)
 133       ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + face : texObj->Target;
 134    return _mesa_get_tex_image(ctx, texObj, faceTarget, level);
 135 }
 136
 137
 138
 139 static GLboolean
 140 initialize_texture_fields(struct gl_context *ctx,
 141                           struct gl_texture_object *texObj,
 142                           GLint levels,
 143                           GLsizei width, GLsizei height, GLsizei depth,
 144                           GLenum internalFormat, gl_format texFormat)
 145 {
 146    const GLenum target = texObj->Target;
 147    const GLuint numFaces = _mesa_num_tex_faces(target);
 148    GLint level, levelWidth = width, levelHeight = height, levelDepth = depth;
 149    GLuint face;
 150
 151    /* Set up all the texture object's gl_texture_images */
 152    for (level = 0; level < levels; level++) {
 153       for (face = 0; face < numFaces; face++) {
 154          struct gl_texture_image *texImage =
 155             get_tex_image(ctx, texObj, face, level);
 156
 157          if (!texImage) {
 158             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexStorage");
 159             return GL_FALSE;
 160          }
 161
 162          _mesa_init_teximage_fields(ctx, texImage,
 163                                     levelWidth, levelHeight, levelDepth,
 164                                     0, internalFormat, texFormat);
 165       }
 166
 167       next_mipmap_level_size(target, &levelWidth, &levelHeight, &levelDepth);
 168    }
 169    return GL_TRUE;
 170 }
 171
 172
 173 /**
 174  * Clear all fields of texture object to zeros.  Used for proxy texture tests.
 175  * Used for proxy texture tests (and to clean up when a texture memory
 176  * allocation fails).
 177  */
 178 static void
 179 clear_texture_fields(struct gl_context *ctx,
 180                      struct gl_texture_object *texObj)
 181 {
 182    const GLenum target = texObj->Target;
 183    const GLuint numFaces = _mesa_num_tex_faces(target);
 184    GLint level;
 185    GLuint face;
 186
 187    for (level = 0; level < Elements(texObj->Image[0]); level++) {
 188       for (face = 0; face < numFaces; face++) {
 189          struct gl_texture_image *texImage =
 190             get_tex_image(ctx, texObj, face, level);
 191
 192          if (!texImage) {
 193             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexStorage");
 194             return;
 195          }
 196
 197          _mesa_init_teximage_fields(ctx, texImage,
 198                                     0, 0, 0, 0, /* w, h, d, border */
 199                                     GL_NONE, MESA_FORMAT_NONE);
 200       }
 201    }
 202 }
 203
 204
 205 GLboolean
 206 _mesa_is_legal_tex_storage_format(struct gl_context *ctx, GLenum internalformat)
 207 {
 208    /* check internal format - note that only sized formats are allowed */
 209    switch (internalformat) {
 210    case GL_ALPHA:
 211    case GL_LUMINANCE:
 212    case GL_LUMINANCE_ALPHA:
 213    case GL_INTENSITY:
 214    case GL_RED:
 215    case GL_RG:
 216    case GL_RGB:
 217    case GL_RGBA:
 218    case GL_BGRA:
 219    case GL_DEPTH_COMPONENT:
 220    case GL_DEPTH_STENCIL:
 221    case GL_COMPRESSED_ALPHA:
 222    case GL_COMPRESSED_LUMINANCE_ALPHA:
 223    case GL_COMPRESSED_LUMINANCE:
 224    case GL_COMPRESSED_INTENSITY:
 225    case GL_COMPRESSED_RGB:
 226    case GL_COMPRESSED_RGBA:
 227    case GL_COMPRESSED_SRGB:
 228    case GL_COMPRESSED_SRGB_ALPHA:
 229    case GL_COMPRESSED_SLUMINANCE:
 230    case GL_COMPRESSED_SLUMINANCE_ALPHA:
 231    case GL_RED_INTEGER:
 232    case GL_GREEN_INTEGER:
 233    case GL_BLUE_INTEGER:
 234    case GL_ALPHA_INTEGER:
 235    case GL_RGB_INTEGER:
 236    case GL_RGBA_INTEGER:
 237    case GL_BGR_INTEGER:
 238    case GL_BGRA_INTEGER:
 239    case GL_LUMINANCE_INTEGER_EXT:
 240    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 241       /* these unsized formats are illegal */
 242       return GL_FALSE;
 243    default:
 244       return _mesa_base_tex_format(ctx, internalformat) > 0;
 245    }
 246 }
 247
 248
 249 /**
 250  * Do error checking for calls to glTexStorage1/2/3D().
 251  * If an error is found, record it with _mesa_error(), unless the target
 252  * is a proxy texture.
 253  * \return GL_TRUE if any error, GL_FALSE otherwise.
 254  */
 255 static GLboolean
 256 tex_storage_error_check(struct gl_context *ctx, GLuint dims, GLenum target,
 257                         GLsizei levels, GLenum internalformat,
 258                         GLsizei width, GLsizei height, GLsizei depth)
 259 {
 260    struct gl_texture_object *texObj;
 261
 262    if (!_mesa_is_legal_tex_storage_format(ctx, internalformat)) {
 263       _mesa_error(ctx, GL_INVALID_ENUM,
 264                   "glTexStorage%uD(internalformat = %s)", dims,
 265                   _mesa_lookup_enum_by_nr(internalformat));
 266       return GL_TRUE;
 267    }
 268
 269    /* size check */
 270    if (width < 1 || height < 1 || depth < 1) {
 271       _mesa_error(ctx, GL_INVALID_VALUE,
 272                   "glTexStorage%uD(width, height or depth < 1)", dims);
 273       return GL_TRUE;
 274    }
 275
 276    /* target check */
 277    if (!legal_texobj_target(ctx, dims, target)) {
 278       _mesa_error(ctx, GL_INVALID_ENUM,
 279                   "glTexStorage%uD(illegal target=%s)",
 280                   dims, _mesa_lookup_enum_by_nr(target));
 281       return GL_TRUE;
 282    }
 283
 284    /* levels check */
 285    if (levels < 1) {
 286       _mesa_error(ctx, GL_INVALID_VALUE, "glTexStorage%uD(levels < 1)",
 287                   dims);
 288       return GL_TRUE;
 289    }
 290
 291    /* check levels against maximum (note different error than above) */
 292    if (levels > (GLint) _mesa_max_texture_levels(ctx, target)) {
 293       _mesa_error(ctx, GL_INVALID_OPERATION,
 294                   "glTexStorage%uD(levels too large)", dims);
 295       return GL_TRUE;
 296    }
 297
 298    /* check levels against width/height/depth */
 299    if (levels > _mesa_get_tex_max_num_levels(target, width, height, depth)) {
 300       _mesa_error(ctx, GL_INVALID_OPERATION,
 301                   "glTexStorage%uD(too many levels for max texture dimension)",
 302                   dims);
 303       return GL_TRUE;
 304    }
 305
 306    /* non-default texture object check */
 307    texObj = _mesa_get_current_tex_object(ctx, target);
 308    if (!texObj || (texObj->Name == 0)) {
 309       _mesa_error(ctx, GL_INVALID_OPERATION,
 310                   "glTexStorage%uD(texture object 0)", dims);
 311       return GL_TRUE;
 312    }
 313
 314    /* Check if texObj->Immutable is set */
 315    if (texObj->Immutable) {
 316       _mesa_error(ctx, GL_INVALID_OPERATION, "glTexStorage%uD(immutable)",
 317                   dims);
 318       return GL_TRUE;
 319    }
 320
 321    return GL_FALSE;
 322 }
 323
 324
 325 /**
 326  * Helper used by _mesa_TexStorage1/2/3D().
 327  */
 328 static void
 329 texstorage(GLuint dims, GLenum target, GLsizei levels, GLenum internalformat,
 330            GLsizei width, GLsizei height, GLsizei depth)
 331 {
 332    struct gl_texture_object *texObj;
 333    GLboolean sizeOK, dimensionsOK;
 334    gl_format texFormat;
 335
 336    GET_CURRENT_CONTEXT(ctx);
 337
 338    if (tex_storage_error_check(ctx, dims, target, levels,
 339                                internalformat, width, height, depth)) {
 340       return; /* error was recorded */
 341    }
 342
 343    texObj = _mesa_get_current_tex_object(ctx, target);
 344    assert(texObj);
 345
 346    texFormat = _mesa_choose_texture_format(ctx, texObj, target, 0,
 347                                            internalformat, GL_NONE, GL_NONE);
 348    assert(texFormat != MESA_FORMAT_NONE);
 349
 350    /* check that width, height, depth are legal for the mipmap level */
 351    dimensionsOK = _mesa_legal_texture_dimensions(ctx, target, 0,
 352                                                   width, height, depth, 0);
 353
 354    sizeOK = ctx->Driver.TestProxyTexImage(ctx, target, 0, texFormat,
 355                                           width, height, depth, 0);
 356
 357    if (_mesa_is_proxy_texture(texObj->Target)) {
 358       if (dimensionsOK && sizeOK) {
 359          initialize_texture_fields(ctx, texObj, levels, width, height, depth,
 360                                    internalformat, texFormat);
 361       }
 362       else {
 363          /* clear all image fields for [levels] */
 364          clear_texture_fields(ctx, texObj);
 365       }
 366    }
 367    else {
 368       if (!dimensionsOK) {
 369          _mesa_error(ctx, GL_INVALID_VALUE,
 370                      "glTexStorage%uD(invalid width, height or depth)", dims);
 371          return;
 372       }
 373
 374       if (!sizeOK) {
 375          _mesa_error(ctx, GL_OUT_OF_MEMORY,
 376                      "glTexStorage%uD(texture too large)", dims);
 377       }
 378
 379       assert(levels > 0);
 380       assert(width > 0);
 381       assert(height > 0);
 382       assert(depth > 0);
 383
 384       if (!initialize_texture_fields(ctx, texObj, levels, width, height, depth,
 385                                      internalformat, texFormat)) {
 386          return;
 387       }
 388
 389       /* Do actual texture memory allocation */
 390       if (!ctx->Driver.AllocTextureStorage(ctx, texObj, levels,
 391                                            width, height, depth)) {
 392          /* Reset the texture images' info to zeros.
 393           * Strictly speaking, we probably don't have to do this since
 394           * generating GL_OUT_OF_MEMORY can leave things in an undefined
 395           * state but this puts things in a consistent state.
 396           */
 397          clear_texture_fields(ctx, texObj);
 398          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexStorage%uD", dims);
 399          return;
 400       }
 401
 402       texObj->Immutable = GL_TRUE;
 403       texObj->ImmutableLevels = levels;
 404    }
 405 }
 406
 407
 408 void GLAPIENTRY
 409 _mesa_TexStorage1D(GLenum target, GLsizei levels, GLenum internalformat,
 410                    GLsizei width)
 411 {
 412    texstorage(1, target, levels, internalformat, width, 1, 1);
 413 }
 414
 415
 416 void GLAPIENTRY
 417 _mesa_TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat,
 418                    GLsizei width, GLsizei height)
 419 {
 420    texstorage(2, target, levels, internalformat, width, height, 1);
 421 }
 422
 423
 424 void GLAPIENTRY
 425 _mesa_TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat,
 426                    GLsizei width, GLsizei height, GLsizei depth)
 427 {
 428    texstorage(3, target, levels, internalformat, width, height, depth);
 429 }
 430
 431
 432
 433 /*
 434  * Note: we don't support GL_EXT_direct_state_access and the spec says
 435  * we don't need the following functions.  However, glew checks for the
 436  * presence of all six functions and will say that GL_ARB_texture_storage
 437  * is not supported if these functions are missing.
 438  */
 439
 440
 441 void GLAPIENTRY
 442 _mesa_TextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels,
 443                           GLenum internalformat,
 444                           GLsizei width)
 445 {
 446    /* no-op */
 447 }
 448
 449
 450 void GLAPIENTRY
 451 _mesa_TextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels,
 452                           GLenum internalformat,
 453                           GLsizei width, GLsizei height)
 454 {
 455    /* no-op */
 456 }
 457
 458
 459
 460 void GLAPIENTRY
 461 _mesa_TextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels,
 462                           GLenum internalformat,
 463                           GLsizei width, GLsizei height, GLsizei depth)
 464 {
 465    /* no-op */
 466 }