← Back to branch summary

~ubuntu-branches/ubuntu/precise/mesa/precise-updates

« back to all changes in this revision

Viewing changes to src/mesa/drivers/dri/i810/i810texmem.c

  • Committer: Package Import Robot
  • Author(s): Robert Hooker
  • Date: 2012-02-02 12:05:48 UTC
  • mfrom: (1.7.1) (3.3.27 sid)
  • Revision ID: package-import@ubuntu.com-20120202120548-nvkma85jq0h4coix
Tags: 8.0~rc2-0ubuntu4
Drop drisearchdir handling, it is no longer needed with multiarch
and dri-alternates being removed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mesa/drivers/dri/i810/i810texmem.c
1
 
/*
2
 
 * GLX Hardware Device Driver for Intel i810
3
 
 * Copyright (C) 1999 Keith Whitwell
4
 
 * Texmem interface changes (C) 2003 Dave Airlie
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
 
 * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM,
20
 
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
21
 
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
22
 
 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23
 
 *
24
 
 */
25
 
 
26
 
#include "main/glheader.h"
27
 
#include "main/macros.h"
28
 
#include "main/mtypes.h"
29
 
#include "main/simple_list.h"
30
 
#include "main/enums.h"
31
 
#include "main/colormac.h"
32
 
#include "main/mm.h"
33
 
 
34
 
#include "i810screen.h"
35
 
#include "i810_dri.h"
36
 
#include "i810context.h"
37
 
#include "i810tex.h"
38
 
#include "i810ioctl.h"
39
 
 
40
 
 
41
 
void i810DestroyTexObj(i810ContextPtr imesa, i810TextureObjectPtr t)
42
 
{
43
 
   /* See if it was the driver's current object.
44
 
    */
45
 
   if ( imesa != NULL ) { 
46
 
     if (imesa->CurrentTexObj[0] == t) {
47
 
       imesa->CurrentTexObj[0] = 0;
48
 
       imesa->dirty &= ~I810_UPLOAD_TEX0;
49
 
     }
50
 
     
51
 
     if (imesa->CurrentTexObj[1] == t) {
52
 
       imesa->CurrentTexObj[1] = 0;
53
 
       imesa->dirty &= ~I810_UPLOAD_TEX1;
54
 
     }
55
 
   }
56
 
}
57
 
 
58
 
 
59
 
 
60
 
#if defined(i386) || defined(__i386__)
61
 
/* From linux kernel i386 header files, copes with odd sizes better
62
 
 * than COPY_DWORDS would:
63
 
 */
64
 
static INLINE void * __memcpy(void * to, const void * from, size_t n)
65
 
{
66
 
int d0, d1, d2;
67
 
__asm__ __volatile__(
68
 
        "rep ; movsl\n\t"
69
 
        "testb $2,%b4\n\t"
70
 
        "je 1f\n\t"
71
 
        "movsw\n"
72
 
        "1:\ttestb $1,%b4\n\t"
73
 
        "je 2f\n\t"
74
 
        "movsb\n"
75
 
        "2:"
76
 
        : "=&c" (d0), "=&D" (d1), "=&S" (d2)
77
 
        :"0" (n/4), "q" (n),"1" ((long) to),"2" ((long) from)
78
 
        : "memory");
79
 
return (to);
80
 
}
81
 
#else
82
 
/* Allow compilation on other architectures */
83
 
#define __memcpy memcpy
84
 
#endif
85
 
 
86
 
/* Upload an image from mesa's internal copy.
87
 
 */
88
 
static void i810UploadTexLevel( i810ContextPtr imesa,
89
 
                                i810TextureObjectPtr t, int hwlevel )
90
 
{
91
 
   const struct gl_texture_image *image = t->image[hwlevel].image;
92
 
   int j;
93
 
   GLuint texelBytes;
94
 
 
95
 
   if (!image || !image->Data)
96
 
      return;
97
 
 
98
 
   texelBytes = _mesa_get_format_bytes(image->TexFormat);
99
 
 
100
 
   if (image->Width * texelBytes == t->Pitch) {
101
 
         GLubyte *dst = (GLubyte *)(t->BufAddr + t->image[hwlevel].offset);
102
 
         GLubyte *src = (GLubyte *)image->Data;
103
 
         
104
 
         memcpy( dst, src, t->Pitch * image->Height );
105
 
   }
106
 
   else {
107
 
      switch (texelBytes) {
108
 
      case 1:
109
 
         {
110
 
            GLubyte *dst = (GLubyte *)(t->BufAddr + t->image[hwlevel].offset);
111
 
            GLubyte *src = (GLubyte *)image->Data;
112
 
 
113
 
            for (j = 0 ; j < image->Height ; j++, dst += t->Pitch) {
114
 
               __memcpy(dst, src, image->Width );
115
 
               src += image->Width;
116
 
            }
117
 
         }
118
 
         break;
119
 
      case 2:
120
 
         {
121
 
            GLushort *dst = (GLushort *)(t->BufAddr + t->image[hwlevel].offset);
122
 
            GLushort *src = (GLushort *)image->Data;
123
 
 
124
 
            for (j = 0 ; j < image->Height ; j++, dst += (t->Pitch/2)) {
125
 
               __memcpy(dst, src, image->Width * 2 );
126
 
               src += image->Width;
127
 
            }
128
 
         }
129
 
         break;
130
 
      default:
131
 
         fprintf(stderr, "%s: Not supported texel size %d\n",
132
 
                 __FUNCTION__, texelBytes);
133
 
      }
134
 
   }
135
 
}
136
 
 
137
 
/* This is called with the lock held.  May have to eject our own and/or
138
 
 * other client's texture objects to make room for the upload.
139
 
 */
140
 
int i810UploadTexImagesLocked( i810ContextPtr imesa, i810TextureObjectPtr t )
141
 
{
142
 
   int i;
143
 
   int ofs;
144
 
   int numLevels;
145
 
 
146
 
   /* Do we need to eject LRU texture objects?
147
 
    */
148
 
   if (!t->base.memBlock) {
149
 
      int heap;
150
 
       
151
 
      heap = driAllocateTexture( imesa->texture_heaps, imesa->nr_heaps,
152
 
                                 (driTextureObject *) t);
153
 
      
154
 
      if ( heap == -1 ) {
155
 
        return -1;
156
 
      }
157
 
      
158
 
      assert(t->base.memBlock);
159
 
      ofs = t->base.memBlock->ofs;
160
 
      t->BufAddr = imesa->i810Screen->tex.map + ofs;
161
 
      t->Setup[I810_TEXREG_MI3] = imesa->i810Screen->textureOffset + ofs;
162
 
      
163
 
      if (t == imesa->CurrentTexObj[0])
164
 
        I810_STATECHANGE(imesa, I810_UPLOAD_TEX0);
165
 
      
166
 
      if (t == imesa->CurrentTexObj[1])
167
 
         I810_STATECHANGE(imesa, I810_UPLOAD_TEX1);
168
 
      
169
 
       /*      i810UpdateTexLRU( imesa, t );*/
170
 
     }
171
 
   driUpdateTextureLRU( (driTextureObject *) t );
172
 
   
173
 
   if (imesa->texture_heaps[0]->timestamp >= GET_DISPATCH_AGE(imesa))
174
 
      i810WaitAgeLocked( imesa, imesa->texture_heaps[0]->timestamp );
175
 
 
176
 
   numLevels = t->base.lastLevel - t->base.firstLevel + 1;
177
 
   for (i = 0 ; i < numLevels ; i++)
178
 
      if (t->base.dirty_images[0] & (1<<i))
179
 
         i810UploadTexLevel( imesa, t, i );
180
 
 
181
 
   t->base.dirty_images[0] = 0;
182
 
 
183
 
   return 0;
184
 
}