1 /**************************************************************************
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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.
26 **************************************************************************/
30 * glReadPixels interface to pipe
36 #include "main/imports.h"
37 #include "main/bufferobj.h"
38 #include "main/context.h"
39 #include "main/image.h"
41 #include "pipe/p_context.h"
42 #include "pipe/p_defines.h"
43 #include "pipe/p_inlines.h"
44 #include "util/u_tile.h"
45 #include "st_context.h"
46 #include "st_cb_bitmap.h"
47 #include "st_cb_readpixels.h"
48 #include "st_cb_fbo.h"
49 #include "st_format.h"
50 #include "st_public.h"
54 * Special case for reading stencil buffer.
55 * For color/depth we use get_tile(). For stencil, map the stencil buffer.
58 st_read_stencil_pixels(GLcontext
*ctx
, GLint x
, GLint y
,
59 GLsizei width
, GLsizei height
, GLenum type
,
60 const struct gl_pixelstore_attrib
*packing
,
63 struct gl_framebuffer
*fb
= ctx
->ReadBuffer
;
64 struct pipe_screen
*screen
= ctx
->st
->pipe
->screen
;
65 struct st_renderbuffer
*strb
= st_renderbuffer(fb
->_StencilBuffer
);
66 struct pipe_surface
*ps
;
70 /* Create a CPU-READ surface/view into the renderbuffer's texture */
71 ps
= screen
->get_tex_surface(screen
, strb
->texture
, 0, 0, 0,
72 PIPE_BUFFER_USAGE_CPU_READ
);
74 /* map the stencil buffer */
75 stmap
= screen
->surface_map(screen
, ps
, PIPE_BUFFER_USAGE_CPU_READ
);
77 /* width should never be > MAX_WIDTH since we did clipping earlier */
78 ASSERT(width
<= MAX_WIDTH
);
80 /* process image row by row */
81 for (j
= 0; j
< height
; j
++, y
++) {
83 GLstencil values
[MAX_WIDTH
];
86 if (st_fb_orientation(ctx
->DrawBuffer
) == Y_0_TOP
) {
87 srcY
= ctx
->DrawBuffer
->Height
- y
- 1;
93 /* get stencil values */
95 case PIPE_FORMAT_S8_UNORM
:
97 const ubyte
*src
= stmap
+ srcY
* ps
->stride
+ x
;
98 memcpy(values
, src
, width
);
101 case PIPE_FORMAT_S8Z24_UNORM
:
103 const uint
*src
= (uint
*) (stmap
+ srcY
* ps
->stride
+ x
*4);
105 for (k
= 0; k
< width
; k
++) {
106 values
[k
] = src
[k
] >> 24;
110 case PIPE_FORMAT_Z24S8_UNORM
:
112 const uint
*src
= (uint
*) (stmap
+ srcY
* ps
->stride
+ x
*4);
114 for (k
= 0; k
< width
; k
++) {
115 values
[k
] = src
[k
] & 0xff;
124 dest
= _mesa_image_address2d(packing
, pixels
, width
, height
,
125 GL_STENCIL_INDEX
, type
, j
, 0);
127 _mesa_pack_stencil_span(ctx
, width
, type
, dest
, values
, packing
);
131 /* unmap the stencil buffer */
132 screen
->surface_unmap(screen
, ps
);
133 pipe_surface_reference(&ps
, NULL
);
138 * Return renderbuffer to use for reading color pixels for glRead/CopyPixel
140 * Special care is needed for the front buffer.
142 struct st_renderbuffer
*
143 st_get_color_read_renderbuffer(GLcontext
*ctx
)
145 struct gl_framebuffer
*fb
= ctx
->ReadBuffer
;
146 struct st_renderbuffer
*strb
=
147 st_renderbuffer(fb
->_ColorReadBuffer
);
148 struct st_renderbuffer
*front
=
149 st_renderbuffer(fb
->Attachment
[BUFFER_FRONT_LEFT
].Renderbuffer
);
152 && ctx
->st
->frontbuffer_status
== FRONT_STATUS_COPY_OF_BACK
) {
153 /* reading from front color buffer, which is a logical copy of the
156 struct st_renderbuffer
*back
=
157 st_renderbuffer(fb
->Attachment
[BUFFER_BACK_LEFT
].Renderbuffer
);
166 * Try to do glReadPixels in a fast manner for common cases.
167 * \return GL_TRUE for success, GL_FALSE for failure
170 st_fast_readpixels(GLcontext
*ctx
, struct st_renderbuffer
*strb
,
171 GLint x
, GLint y
, GLsizei width
, GLsizei height
,
172 GLenum format
, GLenum type
,
173 const struct gl_pixelstore_attrib
*pack
,
177 A8R8G8B8_UNORM_TO_RGBA_UBYTE
,
178 A8R8G8B8_UNORM_TO_RGB_UBYTE
,
179 A8R8G8B8_UNORM_TO_BGRA_UINT
182 if (ctx
->_ImageTransferState
)
185 if (strb
->format
== PIPE_FORMAT_A8R8G8B8_UNORM
&&
186 format
== GL_RGBA
&& type
== GL_UNSIGNED_BYTE
) {
187 combo
= A8R8G8B8_UNORM_TO_RGBA_UBYTE
;
189 else if (strb
->format
== PIPE_FORMAT_A8R8G8B8_UNORM
&&
190 format
== GL_RGB
&& type
== GL_UNSIGNED_BYTE
) {
191 combo
= A8R8G8B8_UNORM_TO_RGB_UBYTE
;
193 else if (strb
->format
== PIPE_FORMAT_A8R8G8B8_UNORM
&&
194 format
== GL_BGRA
&& type
== GL_UNSIGNED_INT_8_8_8_8_REV
) {
195 combo
= A8R8G8B8_UNORM_TO_BGRA_UINT
;
201 /*printf("st_fast_readpixels combo %d\n", (GLint) combo);*/
204 struct pipe_context
*pipe
= ctx
->st
->pipe
;
205 struct pipe_screen
*screen
= pipe
->screen
;
206 struct pipe_surface
*surf
;
209 GLint row
, col
, dy
, dstStride
;
211 surf
= screen
->get_tex_surface(screen
, strb
->texture
, 0, 0, 0,
212 PIPE_BUFFER_USAGE_CPU_READ
);
217 map
= screen
->surface_map(screen
, surf
, PIPE_BUFFER_USAGE_CPU_READ
);
219 pipe_surface_reference(&surf
, NULL
);
223 if (st_fb_orientation(ctx
->ReadBuffer
) == Y_0_TOP
) {
224 y
= surf
->height
- y
- 1;
231 dst
= _mesa_image_address2d(pack
, dest
, width
, height
,
233 dstStride
= _mesa_image_row_stride(pack
, width
, format
, type
);
236 case A8R8G8B8_UNORM_TO_RGBA_UBYTE
:
237 for (row
= 0; row
< height
; row
++) {
238 const GLubyte
*src
= map
+ y
* surf
->stride
+ x
* 4;
239 for (col
= 0; col
< width
; col
++) {
240 GLuint pixel
= ((GLuint
*) src
)[col
];
241 dst
[col
*4+0] = (pixel
>> 16) & 0xff;
242 dst
[col
*4+1] = (pixel
>> 8) & 0xff;
243 dst
[col
*4+2] = (pixel
>> 0) & 0xff;
244 dst
[col
*4+3] = (pixel
>> 24) & 0xff;
250 case A8R8G8B8_UNORM_TO_RGB_UBYTE
:
251 for (row
= 0; row
< height
; row
++) {
252 const GLubyte
*src
= map
+ y
* surf
->stride
+ x
* 4;
253 for (col
= 0; col
< width
; col
++) {
254 GLuint pixel
= ((GLuint
*) src
)[col
];
255 dst
[col
*3+0] = (pixel
>> 16) & 0xff;
256 dst
[col
*3+1] = (pixel
>> 8) & 0xff;
257 dst
[col
*3+2] = (pixel
>> 0) & 0xff;
263 case A8R8G8B8_UNORM_TO_BGRA_UINT
:
264 for (row
= 0; row
< height
; row
++) {
265 const GLubyte
*src
= map
+ y
* surf
->stride
+ x
* 4;
266 memcpy(dst
, src
, 4 * width
);
275 screen
->surface_unmap(screen
, surf
);
276 pipe_surface_reference(&surf
, NULL
);
284 * Do glReadPixels by getting rows from the framebuffer surface with
285 * get_tile(). Convert to requested format/type with Mesa image routines.
286 * Image transfer ops are done in software too.
289 st_readpixels(GLcontext
*ctx
, GLint x
, GLint y
, GLsizei width
, GLsizei height
,
290 GLenum format
, GLenum type
,
291 const struct gl_pixelstore_attrib
*pack
,
294 struct pipe_context
*pipe
= ctx
->st
->pipe
;
295 struct pipe_screen
*screen
= pipe
->screen
;
296 GLfloat temp
[MAX_WIDTH
][4];
297 const GLbitfield transferOps
= ctx
->_ImageTransferState
;
299 GLint yStep
, dfStride
;
301 struct st_renderbuffer
*strb
;
302 struct gl_pixelstore_attrib clippedPacking
= *pack
;
303 struct pipe_surface
*surf
;
305 assert(ctx
->ReadBuffer
->Width
> 0);
307 /* XXX convolution not done yet */
308 assert((transferOps
& IMAGE_CONVOLUTION_BIT
) == 0);
310 /* Do all needed clipping here, so that we can forget about it later */
311 if (!_mesa_clip_readpixels(ctx
, &x
, &y
, &width
, &height
, &clippedPacking
)) {
312 /* The ReadPixels surface is totally outside the window bounds */
316 dest
= _mesa_map_readpix_pbo(ctx
, &clippedPacking
, dest
);
320 st_flush_bitmap_cache(ctx
->st
);
322 /* make sure rendering has completed */
323 pipe
->flush(pipe
, PIPE_FLUSH_RENDER_CACHE
, NULL
);
325 if (format
== GL_STENCIL_INDEX
) {
326 st_read_stencil_pixels(ctx
, x
, y
, width
, height
, type
, pack
, dest
);
329 else if (format
== GL_DEPTH_COMPONENT
) {
330 strb
= st_renderbuffer(ctx
->ReadBuffer
->_DepthBuffer
);
333 /* Read color buffer */
334 strb
= st_get_color_read_renderbuffer(ctx
);
340 /* try a fast-path readpixels before anything else */
341 if (st_fast_readpixels(ctx
, strb
, x
, y
, width
, height
,
342 format
, type
, pack
, dest
)) {
344 _mesa_unmap_readpix_pbo(ctx
, &clippedPacking
);
348 if (format
== GL_RGBA
&& type
== GL_FLOAT
) {
349 /* write tile(row) directly into user's buffer */
350 df
= (GLfloat
*) _mesa_image_address2d(&clippedPacking
, dest
, width
,
351 height
, format
, type
, 0, 0);
352 dfStride
= width
* 4;
355 /* write tile(row) into temp row buffer */
356 df
= (GLfloat
*) temp
;
360 /* determine bottom-to-top vs. top-to-bottom order */
361 if (st_fb_orientation(ctx
->ReadBuffer
) == Y_0_TOP
) {
362 y
= strb
->Base
.Height
- 1 - y
;
369 /* Create a CPU-READ surface/view into the renderbuffer's texture */
370 surf
= screen
->get_tex_surface(screen
, strb
->texture
, 0, 0, 0,
371 PIPE_BUFFER_USAGE_CPU_READ
);
374 * Copy pixels from pipe_surface to user memory
377 /* dest of first pixel in client memory */
378 GLubyte
*dst
= _mesa_image_address2d(&clippedPacking
, dest
, width
,
379 height
, format
, type
, 0, 0);
380 /* dest row stride */
381 const GLint dstStride
= _mesa_image_row_stride(&clippedPacking
, width
,
384 if (surf
->format
== PIPE_FORMAT_S8Z24_UNORM
||
385 surf
->format
== PIPE_FORMAT_X8Z24_UNORM
) {
386 if (format
== GL_DEPTH_COMPONENT
) {
387 for (i
= 0; i
< height
; i
++) {
388 GLuint ztemp
[MAX_WIDTH
];
389 GLfloat zfloat
[MAX_WIDTH
];
390 const double scale
= 1.0 / ((1 << 24) - 1);
391 pipe_get_tile_raw(surf
, x
, y
, width
, 1, ztemp
, 0);
393 for (j
= 0; j
< width
; j
++) {
394 zfloat
[j
] = (float) (scale
* (ztemp
[j
] & 0xffffff));
396 _mesa_pack_depth_span(ctx
, width
, dst
, type
,
397 zfloat
, &clippedPacking
);
402 /* untested, but simple: */
403 assert(format
== GL_DEPTH_STENCIL_EXT
);
404 for (i
= 0; i
< height
; i
++) {
405 pipe_get_tile_raw(surf
, x
, y
, width
, 1, dst
, 0);
411 else if (surf
->format
== PIPE_FORMAT_Z16_UNORM
) {
412 for (i
= 0; i
< height
; i
++) {
413 GLushort ztemp
[MAX_WIDTH
];
414 GLfloat zfloat
[MAX_WIDTH
];
415 const double scale
= 1.0 / 0xffff;
416 pipe_get_tile_raw(surf
, x
, y
, width
, 1, ztemp
, 0);
418 for (j
= 0; j
< width
; j
++) {
419 zfloat
[j
] = (float) (scale
* ztemp
[j
]);
421 _mesa_pack_depth_span(ctx
, width
, dst
, type
,
422 zfloat
, &clippedPacking
);
426 else if (surf
->format
== PIPE_FORMAT_Z32_UNORM
) {
427 for (i
= 0; i
< height
; i
++) {
428 GLuint ztemp
[MAX_WIDTH
];
429 GLfloat zfloat
[MAX_WIDTH
];
430 const double scale
= 1.0 / 0xffffffff;
431 pipe_get_tile_raw(surf
, x
, y
, width
, 1, ztemp
, 0);
433 for (j
= 0; j
< width
; j
++) {
434 zfloat
[j
] = (float) (scale
* ztemp
[j
]);
436 _mesa_pack_depth_span(ctx
, width
, dst
, type
,
437 zfloat
, &clippedPacking
);
443 /* Do a row at a time to flip image data vertically */
444 for (i
= 0; i
< height
; i
++) {
445 pipe_get_tile_rgba(surf
, x
, y
, width
, 1, df
);
449 _mesa_pack_rgba_span_float(ctx
, width
, temp
, format
, type
, dst
,
450 &clippedPacking
, transferOps
);
457 pipe_surface_reference(&surf
, NULL
);
459 _mesa_unmap_readpix_pbo(ctx
, &clippedPacking
);
463 void st_init_readpixels_functions(struct dd_function_table
*functions
)
465 functions
->ReadPixels
= st_readpixels
;