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

   1 #include "swrast/swrast.h"
   2 #include "texobj.h"
   3 #include "mipmap.h"
   4 #include "intel_context.h"
   5 #include "intel_mipmap_tree.h"
   6 #include "intel_tex.h"
   7
   8 #define FILE_DEBUG_FLAG DEBUG_TEXTURE
   9
  10 static GLboolean
  11 intelIsTextureResident(GLcontext * ctx, struct gl_texture_object *texObj)
  12 {
  13 #if 0
  14    struct intel_context *intel = intel_context(ctx);
  15    struct intel_texture_object *intelObj = intel_texture_object(texObj);
  16
  17    return
  18       intelObj->mt &&
  19       intelObj->mt->region &&
  20       intel_is_region_resident(intel, intelObj->mt->region);
  21 #endif
  22    return 1;
  23 }
  24
  25
  26
  27 static struct gl_texture_image *
  28 intelNewTextureImage(GLcontext * ctx)
  29 {
  30    DBG("%s\n", __FUNCTION__);
  31    (void) ctx;
  32    return (struct gl_texture_image *) CALLOC_STRUCT(intel_texture_image);
  33 }
  34
  35
  36 static struct gl_texture_object *
  37 intelNewTextureObject(GLcontext * ctx, GLuint name, GLenum target)
  38 {
  39    struct intel_texture_object *obj = CALLOC_STRUCT(intel_texture_object);
  40
  41    DBG("%s\n", __FUNCTION__);
  42    _mesa_initialize_texture_object(&obj->base, name, target);
  43
  44    return &obj->base;
  45 }
  46
  47 static void
  48 intelDeleteTextureObject(GLcontext *ctx,
  49                          struct gl_texture_object *texObj)
  50 {
  51    struct intel_context *intel = intel_context(ctx);
  52    struct intel_texture_object *intelObj = intel_texture_object(texObj);
  53
  54    if (intelObj->mt)
  55       intel_miptree_release(intel, &intelObj->mt);
  56
  57    _mesa_delete_texture_object(ctx, texObj);
  58 }
  59
  60
  61 static void
  62 intelFreeTextureImageData(GLcontext * ctx, struct gl_texture_image *texImage)
  63 {
  64    struct intel_context *intel = intel_context(ctx);
  65    struct intel_texture_image *intelImage = intel_texture_image(texImage);
  66
  67    DBG("%s\n", __FUNCTION__);
  68
  69    if (intelImage->mt) {
  70       intel_miptree_release(intel, &intelImage->mt);
  71    }
  72
  73    if (texImage->Data) {
  74       free(texImage->Data);
  75       texImage->Data = NULL;
  76    }
  77 }
  78
  79
  80 /* The system memcpy (at least on ubuntu 5.10) has problems copying
  81  * to agp (writecombined) memory from a source which isn't 64-byte
  82  * aligned - there is a 4x performance falloff.
  83  *
  84  * The x86 __memcpy is immune to this but is slightly slower
  85  * (10%-ish) than the system memcpy.
  86  *
  87  * The sse_memcpy seems to have a slight cliff at 64/32 bytes, but
  88  * isn't much faster than x86_memcpy for agp copies.
  89  *
  90  * TODO: switch dynamically.
  91  */
  92 static void *
  93 do_memcpy(void *dest, const void *src, size_t n)
  94 {
  95    if ((((unsigned) src) & 63) || (((unsigned) dest) & 63)) {
  96       return __memcpy(dest, src, n);
  97    }
  98    else
  99       return memcpy(dest, src, n);
 100 }
 101
 102
 103 #if DO_DEBUG
 104
 105 #ifndef __x86_64__
 106 static unsigned
 107 fastrdtsc(void)
 108 {
 109    unsigned eax;
 110    __asm__ volatile ("\t"
 111                      "pushl  %%ebx\n\t"
 112                      "cpuid\n\t" ".byte 0x0f, 0x31\n\t"
 113                      "popl %%ebx\n":"=a" (eax)
 114                      :"0"(0)
 115                      :"ecx", "edx", "cc");
 116
 117    return eax;
 118 }
 119 #else
 120 static unsigned
 121 fastrdtsc(void)
 122 {
 123    unsigned eax;
 124    __asm__ volatile ("\t" "cpuid\n\t" ".byte 0x0f, 0x31\n\t":"=a" (eax)
 125                      :"0"(0)
 126                      :"ecx", "edx", "ebx", "cc");
 127
 128    return eax;
 129 }
 130 #endif
 131
 132 static unsigned
 133 time_diff(unsigned t, unsigned t2)
 134 {
 135    return ((t < t2) ? t2 - t : 0xFFFFFFFFU - (t - t2 - 1));
 136 }
 137
 138
 139 static void *
 140 timed_memcpy(void *dest, const void *src, size_t n)
 141 {
 142    void *ret;
 143    unsigned t1, t2;
 144    double rate;
 145
 146    if ((((unsigned) src) & 63) || (((unsigned) dest) & 63))
 147       _mesa_printf("Warning - non-aligned texture copy!\n");
 148
 149    t1 = fastrdtsc();
 150    ret = do_memcpy(dest, src, n);
 151    t2 = fastrdtsc();
 152
 153    rate = time_diff(t1, t2);
 154    rate /= (double) n;
 155    _mesa_printf("timed_memcpy: %u %u --> %f clocks/byte\n", t1, t2, rate);
 156    return ret;
 157 }
 158 #endif /* DO_DEBUG */
 159
 160 /**
 161  * Generate new mipmap data from BASE+1 to BASE+p (the minimally-sized mipmap
 162  * level).
 163  *
 164  * The texture object's miptree must be mapped.
 165  *
 166  * It would be really nice if this was just called by Mesa whenever mipmaps
 167  * needed to be regenerated, rather than us having to remember to do so in
 168  * each texture image modification path.
 169  *
 170  * This function should also include an accelerated path.
 171  */
 172 void
 173 intel_generate_mipmap(GLcontext *ctx, GLenum target,
 174                       const struct gl_texture_unit *texUnit,
 175                       struct gl_texture_object *texObj)
 176 {
 177    struct intel_texture_object *intelObj = intel_texture_object(texObj);
 178    GLuint nr_faces = (intelObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
 179    int face, i;
 180
 181    _mesa_generate_mipmap(ctx, target, texUnit, texObj);
 182
 183    /* Update the level information in our private data in the new images, since
 184     * it didn't get set as part of a normal TexImage path.
 185     */
 186    for (face = 0; face < nr_faces; face++) {
 187       for (i = texObj->BaseLevel + 1; i < texObj->MaxLevel; i++) {
 188          struct intel_texture_image *intelImage;
 189
 190          intelImage = intel_texture_image(texObj->Image[face][i]);
 191          if (intelImage == NULL)
 192             break;
 193
 194          intelImage->level = i;
 195          intelImage->face = face;
 196       }
 197    }
 198 }
 199
 200
 201 void
 202 intelInitTextureFuncs(struct dd_function_table *functions)
 203 {
 204    functions->ChooseTextureFormat = intelChooseTextureFormat;
 205    functions->TexImage1D = intelTexImage1D;
 206    functions->TexImage2D = intelTexImage2D;
 207    functions->TexImage3D = intelTexImage3D;
 208    functions->TexSubImage1D = intelTexSubImage1D;
 209    functions->TexSubImage2D = intelTexSubImage2D;
 210    functions->TexSubImage3D = intelTexSubImage3D;
 211 #ifdef I915
 212    functions->CopyTexImage1D = intelCopyTexImage1D;
 213    functions->CopyTexImage2D = intelCopyTexImage2D;
 214    functions->CopyTexSubImage1D = intelCopyTexSubImage1D;
 215    functions->CopyTexSubImage2D = intelCopyTexSubImage2D;
 216 #else
 217    functions->CopyTexImage1D = _swrast_copy_teximage1d;
 218    functions->CopyTexImage2D = _swrast_copy_teximage2d;
 219    functions->CopyTexSubImage1D = _swrast_copy_texsubimage1d;
 220    functions->CopyTexSubImage2D = _swrast_copy_texsubimage2d;
 221 #endif
 222    functions->GetTexImage = intelGetTexImage;
 223
 224    /* compressed texture functions */
 225    functions->CompressedTexImage2D = intelCompressedTexImage2D;
 226    functions->GetCompressedTexImage = intelGetCompressedTexImage;
 227
 228    functions->NewTextureObject = intelNewTextureObject;
 229    functions->NewTextureImage = intelNewTextureImage;
 230    functions->DeleteTexture = intelDeleteTextureObject;
 231    functions->FreeTexImageData = intelFreeTextureImageData;
 232    functions->UpdateTexturePalette = 0;
 233    functions->IsTextureResident = intelIsTextureResident;
 234
 235 #if DO_DEBUG
 236    if (INTEL_DEBUG & DEBUG_BUFMGR)
 237       functions->TextureMemCpy = timed_memcpy;
 238    else
 239 #endif
 240       functions->TextureMemCpy = do_memcpy;
 241 }