projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch 'mesa_7_7_branch'
[mesa.git] / src / mesa / drivers / dri / intel / intel_pixel_read.c
1 /**************************************************************************
2 *
3 * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * 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, sub license, 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 portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 #include "main/glheader.h"
29 #include "main/enums.h"
30 #include "main/mtypes.h"
31 #include "main/macros.h"
32 #include "main/image.h"
33 #include "main/bufferobj.h"
34 #include "main/state.h"
35 #include "swrast/swrast.h"
36
37 #include "intel_screen.h"
38 #include "intel_context.h"
39 #include "intel_batchbuffer.h"
40 #include "intel_blit.h"
41 #include "intel_buffers.h"
42 #include "intel_regions.h"
43 #include "intel_pixel.h"
44 #include "intel_buffer_objects.h"
45
46 /* For many applications, the new ability to pull the source buffers
47 * back out of the GTT and then do the packing/conversion operations
48 * in software will be as much of an improvement as trying to get the
49 * blitter and/or texture engine to do the work.
50 *
51 * This step is gated on private backbuffers.
52 *
53 * Obviously the frontbuffer can't be pulled back, so that is either
54 * an argument for blit/texture readpixels, or for blitting to a
55 * temporary and then pulling that back.
56 *
57 * When the destination is a pbo, however, it's not clear if it is
58 * ever going to be pulled to main memory (though the access param
59 * will be a good hint). So it sounds like we do want to be able to
60 * choose between blit/texture implementation on the gpu and pullback
61 * and cpu-based copying.
62 *
63 * Unless you can magically turn client memory into a PBO for the
64 * duration of this call, there will be a cpu-based copying step in
65 * any case.
66 */
67
68
69 static GLboolean
70 do_texture_readpixels(GLcontext * ctx,
71 GLint x, GLint y, GLsizei width, GLsizei height,
72 GLenum format, GLenum type,
73 const struct gl_pixelstore_attrib *pack,
74 struct intel_region *dest_region)
75 {
76 #if 0
77 struct intel_context *intel = intel_context(ctx);
78 intelScreenPrivate *screen = intel->intelScreen;
79 GLint pitch = pack->RowLength ? pack->RowLength : width;
80 __DRIdrawable *dPriv = intel->driDrawable;
81 int textureFormat;
82 GLenum glTextureFormat;
83 int destFormat, depthFormat, destPitch;
84 drm_clip_rect_t tmp;
85
86 if (INTEL_DEBUG & DEBUG_PIXEL)
87 fprintf(stderr, "%s\n", __FUNCTION__);
88
89
90 if (ctx->_ImageTransferState ||
91 pack->SwapBytes || pack->LsbFirst || !pack->Invert) {
92 if (INTEL_DEBUG & DEBUG_PIXEL)
93 fprintf(stderr, "%s: check_color failed\n", __FUNCTION__);
94 return GL_FALSE;
95 }
96
97 intel->vtbl.meta_texrect_source(intel, intel_readbuf_region(intel));
98
99 if (!intel->vtbl.meta_render_dest(intel, dest_region, type, format)) {
100 if (INTEL_DEBUG & DEBUG_PIXEL)
101 fprintf(stderr, "%s: couldn't set dest %s/%s\n",
102 __FUNCTION__,
103 _mesa_lookup_enum_by_nr(type),
104 _mesa_lookup_enum_by_nr(format));
105 return GL_FALSE;
106 }
107
108 if (intel->driDrawable->numClipRects) {
109 intel->vtbl.install_meta_state(intel);
110 intel->vtbl.meta_no_depth_write(intel);
111 intel->vtbl.meta_no_stencil_write(intel);
112
113 if (!driClipRectToFramebuffer(ctx->ReadBuffer, &x, &y, &width, &height)) {
114 SET_STATE(i830, state);
115 if (INTEL_DEBUG & DEBUG_PIXEL)
116 fprintf(stderr, "%s: cliprect failed\n", __FUNCTION__);
117 return GL_TRUE;
118 }
119
120 y = dPriv->h - y - height;
121 x += dPriv->x;
122 y += dPriv->y;
123
124
125 /* Set the frontbuffer up as a large rectangular texture.
126 */
127 intel->vtbl.meta_tex_rect_source(intel, src_region, textureFormat);
128
129
130 intel->vtbl.meta_texture_blend_replace(i830, glTextureFormat);
131
132
133 /* Set the 3d engine to draw into the destination region:
134 */
135
136 intel->vtbl.meta_draw_region(intel, dest_region);
137 intel->vtbl.meta_draw_format(intel, destFormat, depthFormat); /* ?? */
138
139
140 /* Draw a single quad, no cliprects:
141 */
142 intel->vtbl.meta_disable_cliprects(intel);
143
144 intel->vtbl.draw_quad(intel,
145 0, width, 0, height,
146 0x00ff00ff, x, x + width, y, y + height);
147
148 intel->vtbl.leave_meta_state(intel);
149 }
150
151 intel_region_wait_fence(ctx, dest_region); /* required by GL */
152 return GL_TRUE;
153 #endif
154
155 return GL_FALSE;
156 }
157
158
159
160
161 static GLboolean
162 do_blit_readpixels(GLcontext * ctx,
163 GLint x, GLint y, GLsizei width, GLsizei height,
164 GLenum format, GLenum type,
165 const struct gl_pixelstore_attrib *pack, GLvoid * pixels)
166 {
167 struct intel_context *intel = intel_context(ctx);
168 struct intel_region *src = intel_readbuf_region(intel);
169 struct intel_buffer_object *dst = intel_buffer_object(pack->BufferObj);
170 GLuint dst_offset;
171 GLuint rowLength;
172
173 if (INTEL_DEBUG & DEBUG_PIXEL)
174 _mesa_printf("%s\n", __FUNCTION__);
175
176 if (!src)
177 return GL_FALSE;
178
179 if (!_mesa_is_bufferobj(pack->BufferObj)) {
180 /* PBO only for now:
181 */
182 if (INTEL_DEBUG & DEBUG_PIXEL)
183 _mesa_printf("%s - not PBO\n", __FUNCTION__);
184 return GL_FALSE;
185 }
186
187
188 if (ctx->_ImageTransferState ||
189 !intel_check_blit_format(src, format, type)) {
190 if (INTEL_DEBUG & DEBUG_PIXEL)
191 _mesa_printf("%s - bad format for blit\n", __FUNCTION__);
192 return GL_FALSE;
193 }
194
195 if (pack->Alignment != 1 || pack->SwapBytes || pack->LsbFirst) {
196 if (INTEL_DEBUG & DEBUG_PIXEL)
197 _mesa_printf("%s: bad packing params\n", __FUNCTION__);
198 return GL_FALSE;
199 }
200
201 if (pack->RowLength > 0)
202 rowLength = pack->RowLength;
203 else
204 rowLength = width;
205
206 if (pack->Invert) {
207 if (INTEL_DEBUG & DEBUG_PIXEL)
208 _mesa_printf("%s: MESA_PACK_INVERT not done yet\n", __FUNCTION__);
209 return GL_FALSE;
210 }
211 else {
212 rowLength = -rowLength;
213 }
214
215 dst_offset = (GLintptr) _mesa_image_address(2, pack, pixels, width, height,
216 format, type, 0, 0, 0);
217
218
219 /* Although the blits go on the command buffer, need to do this and
220 * fire with lock held to guarentee cliprects are correct.
221 */
222 intelFlush(&intel->ctx);
223
224 if (intel->driReadDrawable->numClipRects) {
225 GLboolean all = (width * height * src->cpp == dst->Base.Size &&
226 x == 0 && dst_offset == 0);
227
228 dri_bo *dst_buffer = intel_bufferobj_buffer(intel, dst,
229 all ? INTEL_WRITE_FULL :
230 INTEL_WRITE_PART);
231 __DRIdrawable *dPriv = intel->driReadDrawable;
232 int nbox = dPriv->numClipRects;
233 drm_clip_rect_t *box = dPriv->pClipRects;
234 drm_clip_rect_t rect;
235 drm_clip_rect_t src_rect;
236 int i;
237
238 src_rect.x1 = dPriv->x + x;
239 src_rect.y1 = dPriv->y + dPriv->h - (y + height);
240 src_rect.x2 = src_rect.x1 + width;
241 src_rect.y2 = src_rect.y1 + height;
242
243
244
245 for (i = 0; i < nbox; i++) {
246 if (!intel_intersect_cliprects(&rect, &src_rect, &box[i]))
247 continue;
248
249 if (!intelEmitCopyBlit(intel,
250 src->cpp,
251 src->pitch, src->buffer, 0, src->tiling,
252 rowLength, dst_buffer, dst_offset, GL_FALSE,
253 rect.x1,
254 rect.y1,
255 rect.x1 - src_rect.x1,
256 rect.y2 - src_rect.y2,
257 rect.x2 - rect.x1, rect.y2 - rect.y1,
258 GL_COPY)) {
259 return GL_FALSE;
260 }
261 }
262 }
263
264 if (INTEL_DEBUG & DEBUG_PIXEL)
265 _mesa_printf("%s - DONE\n", __FUNCTION__);
266
267 return GL_TRUE;
268 }
269
270 void
271 intelReadPixels(GLcontext * ctx,
272 GLint x, GLint y, GLsizei width, GLsizei height,
273 GLenum format, GLenum type,
274 const struct gl_pixelstore_attrib *pack, GLvoid * pixels)
275 {
276 if (INTEL_DEBUG & DEBUG_PIXEL)
277 fprintf(stderr, "%s\n", __FUNCTION__);
278
279 intelFlush(ctx);
280
281 if (do_blit_readpixels
282 (ctx, x, y, width, height, format, type, pack, pixels))
283 return;
284
285 #ifdef I915
286 if (do_texture_readpixels
287 (ctx, x, y, width, height, format, type, pack, pixels))
288 return;
289 #else
290 (void)do_blit_readpixels;
291 (void)do_texture_readpixels;
292 #endif
293
294 if (INTEL_DEBUG & DEBUG_PIXEL)
295 _mesa_printf("%s: fallback to swrast\n", __FUNCTION__);
296
297 /* Update Mesa state before calling down into _swrast_ReadPixels, as
298 * the spans code requires the computed buffer states to be up to date,
299 * but _swrast_ReadPixels only updates Mesa state after setting up
300 * the spans code.
301 */
302
303 if (ctx->NewState)
304 _mesa_update_state(ctx);
305
306 _swrast_ReadPixels(ctx, x, y, width, height, format, type, pack, pixels);
307 }