src/mesa/drivers/dri/i965/intel_tex_validate.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2006 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 #include "mtypes.h"
  29 #include "macros.h"
  30
  31 #include "intel_context.h"
  32 #include "intel_mipmap_tree.h"
  33 #include "intel_tex.h"
  34 #include "bufmgr.h"
  35
  36 /**
  37  * Compute which mipmap levels that really need to be sent to the hardware.
  38  * This depends on the base image size, GL_TEXTURE_MIN_LOD,
  39  * GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, and GL_TEXTURE_MAX_LEVEL.
  40  */
  41 static void intel_calculate_first_last_level( struct intel_texture_object *intelObj )
  42 {
  43    struct gl_texture_object *tObj = &intelObj->base;
  44    const struct gl_texture_image * const baseImage =
  45        tObj->Image[0][tObj->BaseLevel];
  46
  47    /* These must be signed values.  MinLod and MaxLod can be negative numbers,
  48     * and having firstLevel and lastLevel as signed prevents the need for
  49     * extra sign checks.
  50     */
  51    int   firstLevel;
  52    int   lastLevel;
  53
  54    /* Yes, this looks overly complicated, but it's all needed.
  55     */
  56    switch (tObj->Target) {
  57    case GL_TEXTURE_1D:
  58    case GL_TEXTURE_2D:
  59    case GL_TEXTURE_3D:
  60    case GL_TEXTURE_CUBE_MAP:
  61       if (tObj->MinFilter == GL_NEAREST || tObj->MinFilter == GL_LINEAR) {
  62          /* GL_NEAREST and GL_LINEAR only care about GL_TEXTURE_BASE_LEVEL.
  63           */
  64          firstLevel = lastLevel = tObj->BaseLevel;
  65       }
  66       else {
  67          /* Currently not taking min/max lod into account here, those
  68           * values are programmed as sampler state elsewhere and we
  69           * upload the same mipmap levels regardless.  Not sure if
  70           * this makes sense as it means it isn't possible for the app
  71           * to use min/max lod to reduce texture memory pressure:
  72           */
  73          firstLevel = tObj->BaseLevel;
  74          lastLevel = MIN2(tObj->BaseLevel + baseImage->MaxLog2,
  75                           tObj->MaxLevel);
  76          lastLevel = MAX2(firstLevel, lastLevel); /* need at least one level */
  77       }
  78       break;
  79    case GL_TEXTURE_RECTANGLE_NV:
  80    case GL_TEXTURE_4D_SGIS:
  81       firstLevel = lastLevel = 0;
  82       break;
  83    default:
  84       return;
  85    }
  86
  87    /* save these values */
  88    intelObj->firstLevel = firstLevel;
  89    intelObj->lastLevel = lastLevel;
  90 }
  91
  92 static GLboolean copy_image_data_to_tree( struct intel_context *intel,
  93                                           struct intel_texture_object *intelObj,
  94                                           struct gl_texture_image *texImage,
  95                                           GLuint face,
  96                                           GLuint level)
  97 {
  98    return intel_miptree_image_data(intel,
  99                                    intelObj->mt,
 100                                    face,
 101                                    level,
 102                                    texImage->Data,
 103                                    texImage->RowStride,
 104                                    (texImage->RowStride *
 105                                     texImage->Height *
 106                                     texImage->TexFormat->TexelBytes));
 107 }
 108
 109 static void intel_texture_invalidate( struct intel_texture_object *intelObj )
 110 {
 111    GLint nr_faces, face;
 112    intelObj->dirty = ~0;
 113
 114    nr_faces = (intelObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
 115    for (face = 0; face < nr_faces; face++)
 116       intelObj->dirty_images[face] = ~0;
 117 }
 118
 119 static void intel_texture_invalidate_cb( struct intel_context *intel,
 120                                          void *ptr )
 121 {
 122    intel_texture_invalidate( (struct intel_texture_object *) ptr );
 123 }
 124
 125
 126 /*
 127  */
 128 GLuint intel_finalize_mipmap_tree( struct intel_context *intel,
 129                                    struct gl_texture_object *tObj )
 130 {
 131    struct intel_texture_object *intelObj = intel_texture_object(tObj);
 132    GLuint face, i;
 133    GLuint nr_faces = 0;
 134    struct gl_texture_image *firstImage;
 135
 136    /* We know/require this is true by now:
 137     */
 138    assert(intelObj->base.Complete);
 139
 140    /* What levels must the tree include at a minimum?
 141     */
 142    if (intelObj->dirty) {
 143       intel_calculate_first_last_level( intelObj );
 144 /*       intel_miptree_destroy(intel, intelObj->mt); */
 145 /*       intelObj->mt = NULL; */
 146    }
 147
 148    firstImage = intelObj->base.Image[0][intelObj->firstLevel];
 149
 150    /* Fallback case:
 151     */
 152    if (firstImage->Border) {
 153       if (intelObj->mt) {
 154          intel_miptree_destroy(intel, intelObj->mt);
 155          intelObj->mt = NULL;
 156          /* Set all images dirty:
 157           */
 158          intel_texture_invalidate(intelObj);
 159       }
 160       return GL_FALSE;
 161    }
 162
 163
 164
 165    /* Check tree can hold all active levels.  Check tree matches
 166     * target, imageFormat, etc.
 167     */
 168    if (intelObj->mt &&
 169        (intelObj->mt->first_level != intelObj->firstLevel ||
 170         intelObj->mt->last_level != intelObj->lastLevel ||
 171         intelObj->mt->internal_format != firstImage->InternalFormat ||
 172         intelObj->mt->width0 != firstImage->Width ||
 173         intelObj->mt->height0 != firstImage->Height ||
 174         intelObj->mt->depth0 != firstImage->Depth))
 175    {
 176       intel_miptree_destroy(intel, intelObj->mt);
 177       intelObj->mt = NULL;
 178
 179       /* Set all images dirty:
 180        */
 181       intel_texture_invalidate(intelObj);
 182    }
 183
 184
 185    /* May need to create a new tree:
 186     */
 187    if (!intelObj->mt) {
 188       intelObj->mt = intel_miptree_create(intel,
 189                                           intelObj->base.Target,
 190                                           firstImage->InternalFormat,
 191                                           intelObj->firstLevel,
 192                                           intelObj->lastLevel,
 193                                           firstImage->Width,
 194                                           firstImage->Height,
 195                                           firstImage->Depth,
 196                                           firstImage->TexFormat->TexelBytes,
 197                                           firstImage->IsCompressed);
 198
 199       /* Tell the buffer manager that we will manage the backing
 200        * store, but we still want it to do fencing for us.
 201        */
 202       bmBufferSetInvalidateCB(intel,
 203                               intelObj->mt->region->buffer,
 204                               intel_texture_invalidate_cb,
 205                               intelObj,
 206                               GL_FALSE);
 207    }
 208
 209    /* Pull in any images not in the object's tree:
 210     */
 211    if (intelObj->dirty) {
 212       nr_faces = (intelObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
 213       for (face = 0; face < nr_faces; face++) {
 214          if (intelObj->dirty_images[face]) {
 215             for (i = intelObj->firstLevel; i <= intelObj->lastLevel; i++) {
 216                struct gl_texture_image *texImage = intelObj->base.Image[face][i];
 217
 218                /* Need to import images in main memory or held in other trees.
 219                 */
 220                if (intelObj->dirty_images[face] & (1<<i) &&
 221                    texImage) {
 222
 223                   if (INTEL_DEBUG & DEBUG_TEXTURE)
 224                      _mesa_printf("copy data from image %d (%p) into object miptree\n",
 225                                   i,
 226                                   texImage->Data);
 227
 228                   if (!copy_image_data_to_tree(intel,
 229                                                intelObj,
 230                                                texImage,
 231                                                face,
 232                                                i))
 233                      return GL_FALSE;
 234
 235                }
 236             }
 237          }
 238       }
 239
 240       /* Only clear the dirty flags if everything went ok:
 241        */
 242       for (face = 0; face < nr_faces; face++) {
 243          intelObj->dirty_images[face] = 0;
 244       }
 245
 246       intelObj->dirty = 0;
 247    }
 248
 249    return GL_TRUE;
 250 }