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

   1 #include "main/mtypes.h"
   2 #include "main/macros.h"
   3
   4 #include "intel_context.h"
   5 #include "intel_batchbuffer.h"
   6 #include "intel_mipmap_tree.h"
   7 #include "intel_tex.h"
   8
   9 #define FILE_DEBUG_FLAG DEBUG_TEXTURE
  10
  11 /**
  12  * Compute which mipmap levels that really need to be sent to the hardware.
  13  * This depends on the base image size, GL_TEXTURE_MIN_LOD,
  14  * GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, and GL_TEXTURE_MAX_LEVEL.
  15  */
  16 static void
  17 intel_calculate_first_last_level(struct intel_texture_object *intelObj)
  18 {
  19    struct gl_texture_object *tObj = &intelObj->base;
  20    const struct gl_texture_image *const baseImage =
  21       tObj->Image[0][tObj->BaseLevel];
  22
  23    /* These must be signed values.  MinLod and MaxLod can be negative numbers,
  24     * and having firstLevel and lastLevel as signed prevents the need for
  25     * extra sign checks.
  26     */
  27    int firstLevel;
  28    int lastLevel;
  29
  30    /* Yes, this looks overly complicated, but it's all needed.
  31     */
  32    switch (tObj->Target) {
  33    case GL_TEXTURE_1D:
  34    case GL_TEXTURE_2D:
  35    case GL_TEXTURE_3D:
  36    case GL_TEXTURE_CUBE_MAP:
  37       if (tObj->MinFilter == GL_NEAREST || tObj->MinFilter == GL_LINEAR) {
  38          /* GL_NEAREST and GL_LINEAR only care about GL_TEXTURE_BASE_LEVEL.
  39           */
  40          firstLevel = lastLevel = tObj->BaseLevel;
  41       }
  42       else {
  43 #ifdef I915
  44          firstLevel = tObj->BaseLevel + (GLint) (tObj->MinLod + 0.5);
  45          firstLevel = MAX2(firstLevel, tObj->BaseLevel);
  46          firstLevel = MIN2(firstLevel, tObj->BaseLevel + baseImage->MaxLog2);
  47          lastLevel = tObj->BaseLevel + (GLint) (tObj->MaxLod + 0.5);
  48          lastLevel = MAX2(lastLevel, tObj->BaseLevel);
  49          lastLevel = MIN2(lastLevel, tObj->BaseLevel + baseImage->MaxLog2);
  50          lastLevel = MIN2(lastLevel, tObj->MaxLevel);
  51          lastLevel = MAX2(firstLevel, lastLevel);       /* need at least one level */
  52 #else
  53          /* Currently not taking min/max lod into account here, those
  54           * values are programmed as sampler state elsewhere and we
  55           * upload the same mipmap levels regardless.  Not sure if
  56           * this makes sense as it means it isn't possible for the app
  57           * to use min/max lod to reduce texture memory pressure:
  58           */
  59          firstLevel = tObj->BaseLevel;
  60          lastLevel = MIN2(tObj->BaseLevel + baseImage->MaxLog2,
  61                           tObj->MaxLevel);
  62          lastLevel = MAX2(firstLevel, lastLevel); /* need at least one level */
  63 #endif
  64       }
  65       break;
  66    case GL_TEXTURE_RECTANGLE_NV:
  67    case GL_TEXTURE_4D_SGIS:
  68       firstLevel = lastLevel = 0;
  69       break;
  70    default:
  71       return;
  72    }
  73
  74    /* save these values */
  75    intelObj->firstLevel = firstLevel;
  76    intelObj->lastLevel = lastLevel;
  77 }
  78
  79 /**
  80  * Copies the image's contents at its level into the object's miptree,
  81  * and updates the image to point at the object's miptree.
  82  */
  83 static void
  84 copy_image_data_to_tree(struct intel_context *intel,
  85                         struct intel_texture_object *intelObj,
  86                         struct intel_texture_image *intelImage)
  87 {
  88    if (intelImage->mt) {
  89       /* Copy potentially with the blitter:
  90        */
  91       intel_miptree_image_copy(intel,
  92                                intelObj->mt,
  93                                intelImage->face,
  94                                intelImage->level, intelImage->mt);
  95
  96       intel_miptree_release(intel, &intelImage->mt);
  97    }
  98    else {
  99       assert(intelImage->base.Data != NULL);
 100
 101       /* More straightforward upload.
 102        */
 103       intel_miptree_image_data(intel,
 104                                intelObj->mt,
 105                                intelImage->face,
 106                                intelImage->level,
 107                                intelImage->base.Data,
 108                                intelImage->base.RowStride,
 109                                intelImage->base.RowStride *
 110                                intelImage->base.Height);
 111       _mesa_align_free(intelImage->base.Data);
 112       intelImage->base.Data = NULL;
 113    }
 114
 115    intel_miptree_reference(&intelImage->mt, intelObj->mt);
 116 }
 117
 118
 119 /*
 120  */
 121 GLuint
 122 intel_finalize_mipmap_tree(struct intel_context *intel, GLuint unit)
 123 {
 124    struct gl_texture_object *tObj = intel->ctx.Texture.Unit[unit]._Current;
 125    struct intel_texture_object *intelObj = intel_texture_object(tObj);
 126    int comp_byte = 0;
 127    int cpp;
 128    GLuint face, i;
 129    GLuint nr_faces = 0;
 130    struct intel_texture_image *firstImage;
 131
 132    /* We know/require this is true by now:
 133     */
 134    assert(intelObj->base._Complete);
 135
 136    /* What levels must the tree include at a minimum?
 137     */
 138    intel_calculate_first_last_level(intelObj);
 139    firstImage =
 140       intel_texture_image(intelObj->base.Image[0][intelObj->firstLevel]);
 141
 142    /* Fallback case:
 143     */
 144    if (firstImage->base.Border) {
 145       if (intelObj->mt) {
 146          intel_miptree_release(intel, &intelObj->mt);
 147       }
 148       return GL_FALSE;
 149    }
 150
 151
 152    /* If both firstImage and intelObj have a tree which can contain
 153     * all active images, favour firstImage.  Note that because of the
 154     * completeness requirement, we know that the image dimensions
 155     * will match.
 156     */
 157    if (firstImage->mt &&
 158        firstImage->mt != intelObj->mt &&
 159        firstImage->mt->first_level <= intelObj->firstLevel &&
 160        firstImage->mt->last_level >= intelObj->lastLevel) {
 161
 162       if (intelObj->mt)
 163          intel_miptree_release(intel, &intelObj->mt);
 164
 165       intel_miptree_reference(&intelObj->mt, firstImage->mt);
 166    }
 167
 168    if (firstImage->base.IsCompressed) {
 169       comp_byte = intel_compressed_num_bytes(firstImage->base.TexFormat->MesaFormat);
 170       cpp = comp_byte;
 171    }
 172    else cpp = firstImage->base.TexFormat->TexelBytes;
 173
 174    /* Check tree can hold all active levels.  Check tree matches
 175     * target, imageFormat, etc.
 176     *
 177     * XXX: For some layouts (eg i945?), the test might have to be
 178     * first_level == firstLevel, as the tree isn't valid except at the
 179     * original start level.  Hope to get around this by
 180     * programming minLod, maxLod, baseLevel into the hardware and
 181     * leaving the tree alone.
 182     */
 183    if (intelObj->mt &&
 184        (intelObj->mt->target != intelObj->base.Target ||
 185         intelObj->mt->internal_format != firstImage->base.InternalFormat ||
 186         intelObj->mt->first_level != intelObj->firstLevel ||
 187         intelObj->mt->last_level != intelObj->lastLevel ||
 188         intelObj->mt->width0 != firstImage->base.Width ||
 189         intelObj->mt->height0 != firstImage->base.Height ||
 190         intelObj->mt->depth0 != firstImage->base.Depth ||
 191         intelObj->mt->cpp != cpp ||
 192         intelObj->mt->compressed != firstImage->base.IsCompressed)) {
 193       intel_miptree_release(intel, &intelObj->mt);
 194    }
 195
 196
 197    /* May need to create a new tree:
 198     */
 199    if (!intelObj->mt) {
 200       intelObj->mt = intel_miptree_create(intel,
 201                                           intelObj->base.Target,
 202                                           firstImage->base.InternalFormat,
 203                                           intelObj->firstLevel,
 204                                           intelObj->lastLevel,
 205                                           firstImage->base.Width,
 206                                           firstImage->base.Height,
 207                                           firstImage->base.Depth,
 208                                           cpp,
 209                                           comp_byte,
 210                                           GL_TRUE);
 211    }
 212
 213    /* Pull in any images not in the object's tree:
 214     */
 215    nr_faces = (intelObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
 216    for (face = 0; face < nr_faces; face++) {
 217       for (i = intelObj->firstLevel; i <= intelObj->lastLevel; i++) {
 218          struct intel_texture_image *intelImage =
 219             intel_texture_image(intelObj->base.Image[face][i]);
 220
 221          /* Need to import images in main memory or held in other trees.
 222           */
 223          if (intelObj->mt != intelImage->mt) {
 224             copy_image_data_to_tree(intel, intelObj, intelImage);
 225          }
 226       }
 227    }
 228
 229    return GL_TRUE;
 230 }
 231
 232 void
 233 intel_tex_map_level_images(struct intel_context *intel,
 234                            struct intel_texture_object *intelObj,
 235                            int level)
 236 {
 237    GLuint nr_faces = (intelObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
 238    GLuint face;
 239
 240    for (face = 0; face < nr_faces; face++) {
 241       struct intel_texture_image *intelImage =
 242          intel_texture_image(intelObj->base.Image[face][level]);
 243
 244       if (intelImage && intelImage->mt) {
 245          intelImage->base.Data =
 246             intel_miptree_image_map(intel,
 247                                     intelImage->mt,
 248                                     intelImage->face,
 249                                     intelImage->level,
 250                                     &intelImage->base.RowStride,
 251                                     intelImage->base.ImageOffsets);
 252          /* convert stride to texels, not bytes */
 253          intelImage->base.RowStride /= intelImage->mt->cpp;
 254          /* intelImage->base.ImageStride /= intelImage->mt->cpp; */
 255       }
 256    }
 257 }
 258
 259 void
 260 intel_tex_unmap_level_images(struct intel_context *intel,
 261                              struct intel_texture_object *intelObj,
 262                              int level)
 263 {
 264    GLuint nr_faces = (intelObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
 265    GLuint face;
 266
 267    for (face = 0; face < nr_faces; face++) {
 268       struct intel_texture_image *intelImage =
 269          intel_texture_image(intelObj->base.Image[face][level]);
 270
 271       if (intelImage && intelImage->mt) {
 272          intel_miptree_image_unmap(intel, intelImage->mt);
 273          intelImage->base.Data = NULL;
 274       }
 275    }
 276 }
 277
 278 void
 279 intel_tex_map_images(struct intel_context *intel,
 280                      struct intel_texture_object *intelObj)
 281 {
 282    int i;
 283
 284    DBG("%s\n", __FUNCTION__);
 285
 286    for (i = intelObj->firstLevel; i <= intelObj->lastLevel; i++)
 287       intel_tex_map_level_images(intel, intelObj, i);
 288 }
 289
 290 void
 291 intel_tex_unmap_images(struct intel_context *intel,
 292                        struct intel_texture_object *intelObj)
 293 {
 294    int i;
 295
 296    for (i = intelObj->firstLevel; i <= intelObj->lastLevel; i++)
 297       intel_tex_unmap_level_images(intel, intelObj, i);
 298 }