← 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/intel/intel_tex_validate.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/intel/intel_tex_validate.c
4
4
 
5
5
#include "intel_context.h"
6
6
#include "intel_mipmap_tree.h"
 
7
#include "intel_blit.h"
7
8
#include "intel_tex.h"
 
9
#include "intel_tex_layout.h"
8
10
 
9
11
#define FILE_DEBUG_FLAG DEBUG_TEXTURE
10
12
 
14
16
 * but BaseLevel.
15
17
 */
16
18
static void
17
 
intel_update_max_level(struct intel_context *intel,
18
 
                       struct intel_texture_object *intelObj,
 
19
intel_update_max_level(struct intel_texture_object *intelObj,
19
20
                       struct gl_sampler_object *sampler)
20
21
{
21
22
   struct gl_texture_object *tObj = &intelObj->base;
28
29
   }
29
30
}
30
31
 
31
 
/**
32
 
 * Copies the image's contents at its level into the object's miptree,
33
 
 * and updates the image to point at the object's miptree.
34
 
 */
35
 
static void
36
 
copy_image_data_to_tree(struct intel_context *intel,
37
 
                        struct intel_texture_object *intelObj,
38
 
                        struct intel_texture_image *intelImage)
39
 
{
40
 
   if (intelImage->mt) {
41
 
      /* Copy potentially with the blitter:
42
 
       */
43
 
      intel_miptree_image_copy(intel,
44
 
                               intelObj->mt,
45
 
                               intelImage->face,
46
 
                               intelImage->level, intelImage->mt);
47
 
 
48
 
      intel_miptree_release(intel, &intelImage->mt);
49
 
   }
50
 
   else {
51
 
      assert(intelImage->base.Data != NULL);
52
 
 
53
 
      /* More straightforward upload.  
54
 
       */
55
 
      intel_miptree_image_data(intel,
56
 
                               intelObj->mt,
57
 
                               intelImage->face,
58
 
                               intelImage->level,
59
 
                               intelImage->base.Data,
60
 
                               intelImage->base.RowStride,
61
 
                               intelImage->base.RowStride *
62
 
                               intelImage->base.Height);
63
 
      _mesa_align_free(intelImage->base.Data);
64
 
      intelImage->base.Data = NULL;
65
 
   }
66
 
 
67
 
   intel_miptree_reference(&intelImage->mt, intelObj->mt);
68
 
}
69
 
 
70
 
 
71
32
/*  
72
33
 */
73
34
GLuint
80
41
   GLuint face, i;
81
42
   GLuint nr_faces = 0;
82
43
   struct intel_texture_image *firstImage;
 
44
   int width, height, depth;
83
45
 
84
46
   /* We know/require this is true by now: 
85
47
    */
87
49
 
88
50
   /* What levels must the tree include at a minimum?
89
51
    */
90
 
   intel_update_max_level(intel, intelObj, sampler);
 
52
   intel_update_max_level(intelObj, sampler);
91
53
   firstImage = intel_texture_image(tObj->Image[0][tObj->BaseLevel]);
92
54
 
93
 
   /* Fallback case:
94
 
    */
95
 
   if (firstImage->base.Border) {
96
 
      if (intelObj->mt) {
97
 
         intel_miptree_release(intel, &intelObj->mt);
98
 
      }
99
 
      return GL_FALSE;
100
 
   }
101
 
 
102
55
   /* Check tree can hold all active levels.  Check tree matches
103
56
    * target, imageFormat, etc.
104
57
    *
108
61
    * of that, we just always relayout on baselevel change.
109
62
    */
110
63
   if (intelObj->mt &&
111
 
       (intelObj->mt->target != intelObj->base.Target ||
112
 
        intelObj->mt->format != firstImage->base.TexFormat ||
 
64
       (!intel_miptree_match_image(intelObj->mt, &firstImage->base.Base) ||
113
65
        intelObj->mt->first_level != tObj->BaseLevel ||
114
 
        intelObj->mt->last_level < intelObj->_MaxLevel ||
115
 
        intelObj->mt->width0 != firstImage->base.Width ||
116
 
        intelObj->mt->height0 != firstImage->base.Height ||
117
 
        intelObj->mt->depth0 != firstImage->base.Depth)) {
118
 
      intel_miptree_release(intel, &intelObj->mt);
 
66
        intelObj->mt->last_level < intelObj->_MaxLevel)) {
 
67
      intel_miptree_release(&intelObj->mt);
119
68
   }
120
69
 
121
70
 
122
71
   /* May need to create a new tree:
123
72
    */
124
73
   if (!intelObj->mt) {
 
74
      intel_miptree_get_dimensions_for_image(&firstImage->base.Base,
 
75
                                             &width, &height, &depth);
 
76
 
125
77
      intelObj->mt = intel_miptree_create(intel,
126
78
                                          intelObj->base.Target,
127
 
                                          firstImage->base.TexFormat,
 
79
                                          firstImage->base.Base.TexFormat,
128
80
                                          tObj->BaseLevel,
129
81
                                          intelObj->_MaxLevel,
130
 
                                          firstImage->base.Width,
131
 
                                          firstImage->base.Height,
132
 
                                          firstImage->base.Depth,
133
 
                                          GL_TRUE);
 
82
                                          width,
 
83
                                          height,
 
84
                                          depth,
 
85
                                          true);
134
86
      if (!intelObj->mt)
135
 
         return GL_FALSE;
 
87
         return false;
136
88
   }
137
89
 
138
90
   /* Pull in any images not in the object's tree:
153
105
          */
154
106
         if (intelObj->mt != intelImage->mt &&
155
107
             !intelImage->used_as_render_target) {
156
 
            copy_image_data_to_tree(intel, intelObj, intelImage);
 
108
            intel_miptree_copy_teximage(intel, intelImage, intelObj->mt);
157
109
         }
158
110
      }
159
111
   }
160
112
 
161
 
   return GL_TRUE;
162
 
}
163
 
 
164
 
void
165
 
intel_tex_map_level_images(struct intel_context *intel,
166
 
                           struct intel_texture_object *intelObj,
167
 
                           int level)
168
 
{
169
 
   GLuint nr_faces = (intelObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
170
 
   GLuint face;
171
 
 
172
 
   for (face = 0; face < nr_faces; face++) {
173
 
      struct intel_texture_image *intelImage =
174
 
         intel_texture_image(intelObj->base.Image[face][level]);
175
 
 
176
 
      if (intelImage && intelImage->mt) {
177
 
         intelImage->base.Data =
178
 
            intel_miptree_image_map(intel,
179
 
                                    intelImage->mt,
180
 
                                    intelImage->face,
181
 
                                    intelImage->level,
182
 
                                    &intelImage->base.RowStride,
183
 
                                    intelImage->base.ImageOffsets);
184
 
         /* convert stride to texels, not bytes */
185
 
         intelImage->base.RowStride /= intelImage->mt->cpp;
186
 
         /* intelImage->base.ImageStride /= intelImage->mt->cpp; */
187
 
      }
188
 
   }
189
 
}
190
 
 
191
 
void
192
 
intel_tex_unmap_level_images(struct intel_context *intel,
193
 
                             struct intel_texture_object *intelObj,
194
 
                             int level)
195
 
{
196
 
   GLuint nr_faces = (intelObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
197
 
   GLuint face;
198
 
 
199
 
   for (face = 0; face < nr_faces; face++) {
200
 
      struct intel_texture_image *intelImage =
201
 
         intel_texture_image(intelObj->base.Image[face][level]);
202
 
 
203
 
      if (intelImage && intelImage->mt) {
204
 
         intel_miptree_image_unmap(intel, intelImage->mt);
205
 
         intelImage->base.Data = NULL;
206
 
      }
207
 
   }
208
 
}
209
 
 
 
113
   return true;
 
114
}
 
115
 
 
116
/**
 
117
 * \param mode  bitmask of GL_MAP_READ_BIT, GL_MAP_WRITE_BIT
 
118
 */
 
119
static void
 
120
intel_tex_map_image_for_swrast(struct intel_context *intel,
 
121
                               struct intel_texture_image *intel_image,
 
122
                               GLbitfield mode)
 
123
{
 
124
   int level;
 
125
   int face;
 
126
   struct intel_mipmap_tree *mt;
 
127
   unsigned int x, y;
 
128
 
 
129
   if (!intel_image || !intel_image->mt)
 
130
      return;
 
131
 
 
132
   level = intel_image->base.Base.Level;
 
133
   face = intel_image->base.Base.Face;
 
134
   mt = intel_image->mt;
 
135
 
 
136
   if (mt->target == GL_TEXTURE_3D ||
 
137
       mt->target == GL_TEXTURE_2D_ARRAY ||
 
138
       mt->target == GL_TEXTURE_1D_ARRAY) {
 
139
      int i;
 
140
 
 
141
      /* ImageOffsets[] is only used for swrast's fetch_texel_3d, so we can't
 
142
       * share code with the normal path.
 
143
       */
 
144
      for (i = 0; i < mt->level[level].depth; i++) {
 
145
         intel_miptree_get_image_offset(mt, level, face, i, &x, &y);
 
146
         intel_image->base.ImageOffsets[i] = x + y * mt->region->pitch;
 
147
      }
 
148
 
 
149
      DBG("%s \n", __FUNCTION__);
 
150
 
 
151
      intel_image->base.Map = intel_region_map(intel, mt->region, mode);
 
152
   } else {
 
153
      assert(intel_image->base.Base.Depth == 1);
 
154
      intel_miptree_get_image_offset(mt, level, face, 0, &x, &y);
 
155
 
 
156
      DBG("%s: (%d,%d) -> (%d, %d)/%d\n",
 
157
          __FUNCTION__, face, level, x, y, mt->region->pitch * mt->cpp);
 
158
 
 
159
      intel_image->base.Map = intel_region_map(intel, mt->region, mode) +
 
160
         (x + y * mt->region->pitch) * mt->cpp;
 
161
   }
 
162
 
 
163
   intel_image->base.RowStride = mt->region->pitch;
 
164
}
 
165
 
 
166
static void
 
167
intel_tex_unmap_image_for_swrast(struct intel_context *intel,
 
168
                                 struct intel_texture_image *intel_image)
 
169
{
 
170
   if (intel_image && intel_image->mt) {
 
171
      intel_region_unmap(intel, intel_image->mt->region);
 
172
      intel_image->base.Map = NULL;
 
173
   }
 
174
}
 
175
 
 
176
/**
 
177
 * \param mode  bitmask of GL_MAP_READ_BIT, GL_MAP_WRITE_BIT
 
178
 */
210
179
void
211
180
intel_tex_map_images(struct intel_context *intel,
212
 
                     struct intel_texture_object *intelObj)
 
181
                     struct intel_texture_object *intelObj,
 
182
                     GLbitfield mode)
213
183
{
214
 
   int i;
 
184
   GLuint nr_faces = (intelObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
 
185
   int i, face;
215
186
 
216
187
   DBG("%s\n", __FUNCTION__);
217
188
 
218
 
   for (i = intelObj->base.BaseLevel; i <= intelObj->_MaxLevel; i++)
219
 
      intel_tex_map_level_images(intel, intelObj, i);
 
189
   for (i = intelObj->base.BaseLevel; i <= intelObj->_MaxLevel; i++) {
 
190
      for (face = 0; face < nr_faces; face++) {
 
191
         struct intel_texture_image *intel_image =
 
192
            intel_texture_image(intelObj->base.Image[face][i]);
 
193
 
 
194
         intel_tex_map_image_for_swrast(intel, intel_image, mode);
 
195
      }
 
196
   }
220
197
}
221
198
 
222
199
void
223
200
intel_tex_unmap_images(struct intel_context *intel,
224
 
                       struct intel_texture_object *intelObj)
 
201
                       struct intel_texture_object *intelObj)
225
202
{
226
 
   int i;
227
 
 
228
 
   for (i = intelObj->base.BaseLevel; i <= intelObj->_MaxLevel; i++)
229
 
      intel_tex_unmap_level_images(intel, intelObj, i);
 
203
   GLuint nr_faces = (intelObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
 
204
   int i, face;
 
205
 
 
206
   for (i = intelObj->base.BaseLevel; i <= intelObj->_MaxLevel; i++) {
 
207
      for (face = 0; face < nr_faces; face++) {
 
208
         struct intel_texture_image *intel_image =
 
209
            intel_texture_image(intelObj->base.Image[face][i]);
 
210
 
 
211
         intel_tex_unmap_image_for_swrast(intel, intel_image);
 
212
      }
 
213
   }
230
214
}