radeon_mipmap_tree.c revision 1f7c914ad0beea8a29c1a171c7cd1a12f2efe0fa
1/* 2 * Copyright (C) 2008 Nicolai Haehnle. 3 * 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining 7 * a 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, sublicense, 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 16 * portions of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 21 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE 22 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 23 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 24 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 * 26 */ 27 28#include "radeon_mipmap_tree.h" 29 30#include <errno.h> 31#include <unistd.h> 32 33#include "main/simple_list.h" 34#include "main/texcompress.h" 35#include "main/texformat.h" 36 37static GLuint radeon_compressed_texture_size(GLcontext *ctx, 38 GLsizei width, GLsizei height, GLsizei depth, 39 GLuint mesaFormat) 40{ 41 GLuint size = _mesa_compressed_texture_size(ctx, width, height, depth, mesaFormat); 42 43 if (mesaFormat == MESA_FORMAT_RGB_DXT1 || 44 mesaFormat == MESA_FORMAT_RGBA_DXT1) { 45 if (width + 3 < 8) /* width one block */ 46 size = size * 4; 47 else if (width + 3 < 16) 48 size = size * 2; 49 } else { 50 /* DXT3/5, 16 bytes per block */ 51 // WARN_ONCE("DXT 3/5 suffers from multitexturing problems!\n"); 52 if (width + 3 < 8) 53 size = size * 2; 54 } 55 56 return size; 57} 58 59 60static int radeon_compressed_num_bytes(GLuint mesaFormat) 61{ 62 int bytes = 0; 63 switch(mesaFormat) { 64 65 case MESA_FORMAT_RGB_FXT1: 66 case MESA_FORMAT_RGBA_FXT1: 67 case MESA_FORMAT_RGB_DXT1: 68 case MESA_FORMAT_RGBA_DXT1: 69 bytes = 2; 70 break; 71 72 case MESA_FORMAT_RGBA_DXT3: 73 case MESA_FORMAT_RGBA_DXT5: 74 bytes = 4; 75 default: 76 break; 77 } 78 79 return bytes; 80} 81 82/** 83 * Compute sizes and fill in offset and blit information for the given 84 * image (determined by \p face and \p level). 85 * 86 * \param curOffset points to the offset at which the image is to be stored 87 * and is updated by this function according to the size of the image. 88 */ 89static void compute_tex_image_offset(radeonContextPtr rmesa, radeon_mipmap_tree *mt, 90 GLuint face, GLuint level, GLuint* curOffset) 91{ 92 radeon_mipmap_level *lvl = &mt->levels[level]; 93 uint32_t row_align; 94 95 /* Find image size in bytes */ 96 if (mt->compressed) { 97 /* TODO: Is this correct? Need test cases for compressed textures! */ 98 row_align = rmesa->texture_compressed_row_align - 1; 99 lvl->rowstride = (lvl->width * mt->bpp + row_align) & ~row_align; 100 lvl->size = radeon_compressed_texture_size(mt->radeon->glCtx, 101 lvl->width, lvl->height, lvl->depth, mt->compressed); 102 } else if (mt->target == GL_TEXTURE_RECTANGLE_NV) { 103 row_align = rmesa->texture_rect_row_align - 1; 104 lvl->rowstride = (lvl->width * mt->bpp + row_align) & ~row_align; 105 lvl->size = lvl->rowstride * lvl->height; 106 } else if (mt->tilebits & RADEON_TXO_MICRO_TILE) { 107 /* tile pattern is 16 bytes x2. mipmaps stay 32 byte aligned, 108 * though the actual offset may be different (if texture is less than 109 * 32 bytes width) to the untiled case */ 110 lvl->rowstride = (lvl->width * mt->bpp * 2 + 31) & ~31; 111 lvl->size = lvl->rowstride * ((lvl->height + 1) / 2) * lvl->depth; 112 } else { 113 row_align = rmesa->texture_row_align - 1; 114 lvl->rowstride = (lvl->width * mt->bpp + row_align) & ~row_align; 115 lvl->size = lvl->rowstride * lvl->height * lvl->depth; 116 } 117 assert(lvl->size > 0); 118 119 /* All images are aligned to a 32-byte offset */ 120 *curOffset = (*curOffset + 0x1f) & ~0x1f; 121 lvl->faces[face].offset = *curOffset; 122 *curOffset += lvl->size; 123 124 if (RADEON_DEBUG & RADEON_TEXTURE) 125 fprintf(stderr, 126 "level %d, face %d: rs:%d %dx%d at %d\n", 127 level, face, lvl->rowstride, lvl->width, lvl->height, lvl->faces[face].offset); 128} 129 130static GLuint minify(GLuint size, GLuint levels) 131{ 132 size = size >> levels; 133 if (size < 1) 134 size = 1; 135 return size; 136} 137 138 139static void calculate_miptree_layout_r100(radeonContextPtr rmesa, radeon_mipmap_tree *mt) 140{ 141 GLuint curOffset; 142 GLuint numLevels; 143 GLuint i; 144 GLuint face; 145 146 numLevels = mt->lastLevel - mt->firstLevel + 1; 147 assert(numLevels <= rmesa->glCtx->Const.MaxTextureLevels); 148 149 curOffset = 0; 150 for(face = 0; face < mt->faces; face++) { 151 152 for(i = 0; i < numLevels; i++) { 153 mt->levels[i].width = minify(mt->width0, i); 154 mt->levels[i].height = minify(mt->height0, i); 155 mt->levels[i].depth = minify(mt->depth0, i); 156 compute_tex_image_offset(rmesa, mt, face, i, &curOffset); 157 } 158 } 159 160 /* Note the required size in memory */ 161 mt->totalsize = (curOffset + RADEON_OFFSET_MASK) & ~RADEON_OFFSET_MASK; 162} 163 164static void calculate_miptree_layout_r300(radeonContextPtr rmesa, radeon_mipmap_tree *mt) 165{ 166 GLuint curOffset; 167 GLuint numLevels; 168 GLuint i; 169 170 numLevels = mt->lastLevel - mt->firstLevel + 1; 171 assert(numLevels <= rmesa->glCtx->Const.MaxTextureLevels); 172 173 curOffset = 0; 174 for(i = 0; i < numLevels; i++) { 175 GLuint face; 176 177 mt->levels[i].width = minify(mt->width0, i); 178 mt->levels[i].height = minify(mt->height0, i); 179 mt->levels[i].depth = minify(mt->depth0, i); 180 181 for(face = 0; face < mt->faces; face++) 182 compute_tex_image_offset(rmesa, mt, face, i, &curOffset); 183 } 184 185 /* Note the required size in memory */ 186 mt->totalsize = (curOffset + RADEON_OFFSET_MASK) & ~RADEON_OFFSET_MASK; 187} 188 189/** 190 * Create a new mipmap tree, calculate its layout and allocate memory. 191 */ 192radeon_mipmap_tree* radeon_miptree_create(radeonContextPtr rmesa, radeonTexObj *t, 193 GLenum target, GLenum internal_format, GLuint firstLevel, GLuint lastLevel, 194 GLuint width0, GLuint height0, GLuint depth0, 195 GLuint bpp, GLuint tilebits, GLuint compressed) 196{ 197 radeon_mipmap_tree *mt = CALLOC_STRUCT(_radeon_mipmap_tree); 198 199 mt->radeon = rmesa; 200 mt->internal_format = internal_format; 201 mt->refcount = 1; 202 mt->t = t; 203 mt->target = target; 204 mt->faces = (target == GL_TEXTURE_CUBE_MAP) ? 6 : 1; 205 mt->firstLevel = firstLevel; 206 mt->lastLevel = lastLevel; 207 mt->width0 = width0; 208 mt->height0 = height0; 209 mt->depth0 = depth0; 210 mt->bpp = compressed ? radeon_compressed_num_bytes(compressed) : bpp; 211 mt->tilebits = tilebits; 212 mt->compressed = compressed; 213 214 if (rmesa->radeonScreen->chip_family >= CHIP_FAMILY_R300) 215 calculate_miptree_layout_r300(rmesa, mt); 216 else 217 calculate_miptree_layout_r100(rmesa, mt); 218 219 mt->bo = radeon_bo_open(rmesa->radeonScreen->bom, 220 0, mt->totalsize, 1024, 221 RADEON_GEM_DOMAIN_VRAM, 222 0); 223 224 return mt; 225} 226 227void radeon_miptree_reference(radeon_mipmap_tree *mt) 228{ 229 mt->refcount++; 230 assert(mt->refcount > 0); 231} 232 233void radeon_miptree_unreference(radeon_mipmap_tree *mt) 234{ 235 if (!mt) 236 return; 237 238 assert(mt->refcount > 0); 239 mt->refcount--; 240 if (!mt->refcount) { 241 radeon_bo_unref(mt->bo); 242 free(mt); 243 } 244} 245 246 247/** 248 * Calculate first and last mip levels for the given texture object, 249 * where the dimensions are taken from the given texture image at 250 * the given level. 251 * 252 * Note: level is the OpenGL level number, which is not necessarily the same 253 * as the first level that is actually present. 254 * 255 * The base level image of the given texture face must be non-null, 256 * or this will fail. 257 */ 258static void calculate_first_last_level(struct gl_texture_object *tObj, 259 GLuint *pfirstLevel, GLuint *plastLevel, 260 GLuint face, GLuint level) 261{ 262 const struct gl_texture_image * const baseImage = 263 tObj->Image[face][level]; 264 265 assert(baseImage); 266 267 /* These must be signed values. MinLod and MaxLod can be negative numbers, 268 * and having firstLevel and lastLevel as signed prevents the need for 269 * extra sign checks. 270 */ 271 int firstLevel; 272 int lastLevel; 273 274 /* Yes, this looks overly complicated, but it's all needed. 275 */ 276 switch (tObj->Target) { 277 case GL_TEXTURE_1D: 278 case GL_TEXTURE_2D: 279 case GL_TEXTURE_3D: 280 case GL_TEXTURE_CUBE_MAP: 281 if (tObj->MinFilter == GL_NEAREST || tObj->MinFilter == GL_LINEAR) { 282 /* GL_NEAREST and GL_LINEAR only care about GL_TEXTURE_BASE_LEVEL. 283 */ 284 firstLevel = lastLevel = tObj->BaseLevel; 285 } else { 286 firstLevel = tObj->BaseLevel + (GLint)(tObj->MinLod + 0.5); 287 firstLevel = MAX2(firstLevel, tObj->BaseLevel); 288 firstLevel = MIN2(firstLevel, level + baseImage->MaxLog2); 289 lastLevel = tObj->BaseLevel + (GLint)(tObj->MaxLod + 0.5); 290 lastLevel = MAX2(lastLevel, tObj->BaseLevel); 291 lastLevel = MIN2(lastLevel, level + baseImage->MaxLog2); 292 lastLevel = MIN2(lastLevel, tObj->MaxLevel); 293 lastLevel = MAX2(firstLevel, lastLevel); /* need at least one level */ 294 } 295 break; 296 case GL_TEXTURE_RECTANGLE_NV: 297 case GL_TEXTURE_4D_SGIS: 298 firstLevel = lastLevel = 0; 299 break; 300 default: 301 return; 302 } 303 304 /* save these values */ 305 *pfirstLevel = firstLevel; 306 *plastLevel = lastLevel; 307} 308 309 310/** 311 * Checks whether the given miptree can hold the given texture image at the 312 * given face and level. 313 */ 314GLboolean radeon_miptree_matches_image(radeon_mipmap_tree *mt, 315 struct gl_texture_image *texImage, GLuint face, GLuint level) 316{ 317 radeon_mipmap_level *lvl; 318 319 if (face >= mt->faces || level < mt->firstLevel || level > mt->lastLevel) 320 return GL_FALSE; 321 322 if (texImage->InternalFormat != mt->internal_format || 323 texImage->IsCompressed != mt->compressed) 324 return GL_FALSE; 325 326 if (!texImage->IsCompressed && 327 !mt->compressed && 328 _mesa_get_format_bytes(texImage->TexFormat) != mt->bpp) 329 return GL_FALSE; 330 331 lvl = &mt->levels[level - mt->firstLevel]; 332 if (lvl->width != texImage->Width || 333 lvl->height != texImage->Height || 334 lvl->depth != texImage->Depth) 335 return GL_FALSE; 336 337 return GL_TRUE; 338} 339 340 341/** 342 * Checks whether the given miptree has the right format to store the given texture object. 343 */ 344GLboolean radeon_miptree_matches_texture(radeon_mipmap_tree *mt, struct gl_texture_object *texObj) 345{ 346 struct gl_texture_image *firstImage; 347 GLuint compressed; 348 GLuint numfaces = 1; 349 GLuint firstLevel, lastLevel; 350 GLuint texelBytes; 351 352 calculate_first_last_level(texObj, &firstLevel, &lastLevel, 0, texObj->BaseLevel); 353 if (texObj->Target == GL_TEXTURE_CUBE_MAP) 354 numfaces = 6; 355 356 firstImage = texObj->Image[0][firstLevel]; 357 compressed = firstImage->IsCompressed ? firstImage->TexFormat : 0; 358 texelBytes = _mesa_get_format_bytes(firstImage->TexFormat); 359 360 return (mt->firstLevel == firstLevel && 361 mt->lastLevel == lastLevel && 362 mt->width0 == firstImage->Width && 363 mt->height0 == firstImage->Height && 364 mt->depth0 == firstImage->Depth && 365 mt->compressed == compressed && 366 (!mt->compressed ? (mt->bpp == texelBytes) : 1)); 367} 368 369 370/** 371 * Try to allocate a mipmap tree for the given texture that will fit the 372 * given image in the given position. 373 */ 374void radeon_try_alloc_miptree(radeonContextPtr rmesa, radeonTexObj *t, 375 radeon_texture_image *image, GLuint face, GLuint level) 376{ 377 GLuint compressed = image->base.IsCompressed ? image->base.TexFormat : 0; 378 GLuint numfaces = 1; 379 GLuint firstLevel, lastLevel; 380 GLuint texelBytes; 381 382 assert(!t->mt); 383 384 calculate_first_last_level(&t->base, &firstLevel, &lastLevel, face, level); 385 if (t->base.Target == GL_TEXTURE_CUBE_MAP) 386 numfaces = 6; 387 388 if (level != firstLevel || face >= numfaces) 389 return; 390 391 texelBytes = _mesa_get_format_bytes(image->base.TexFormat); 392 393 t->mt = radeon_miptree_create(rmesa, t, t->base.Target, 394 image->base.InternalFormat, 395 firstLevel, lastLevel, 396 image->base.Width, image->base.Height, image->base.Depth, 397 texelBytes, t->tile_bits, compressed); 398} 399 400/* Although we use the image_offset[] array to store relative offsets 401 * to cube faces, Mesa doesn't know anything about this and expects 402 * each cube face to be treated as a separate image. 403 * 404 * These functions present that view to mesa: 405 */ 406void 407radeon_miptree_depth_offsets(radeon_mipmap_tree *mt, GLuint level, GLuint *offsets) 408{ 409 if (mt->target != GL_TEXTURE_3D || mt->faces == 1) 410 offsets[0] = 0; 411 else { 412 int i; 413 for (i = 0; i < 6; i++) 414 offsets[i] = mt->levels[level].faces[i].offset; 415 } 416} 417 418GLuint 419radeon_miptree_image_offset(radeon_mipmap_tree *mt, 420 GLuint face, GLuint level) 421{ 422 if (mt->target == GL_TEXTURE_CUBE_MAP_ARB) 423 return (mt->levels[level].faces[face].offset); 424 else 425 return mt->levels[level].faces[0].offset; 426} 427