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"
46 #include "st_context.h"
47 #include "st_cb_bitmap.h"
48 #include "st_cb_readpixels.h"
49 #include "st_cb_fbo.h"
50 #include "st_format.h"
51 #include "st_public.h"
52 #include "st_texture.h"
53 #include "st_inlines.h"
56 * Special case for reading stencil buffer.
57 * For color/depth we use get_tile(). For stencil, map the stencil buffer.
60 st_read_stencil_pixels(GLcontext
*ctx
, GLint x
, GLint y
,
61 GLsizei width
, GLsizei height
,
62 GLenum format
, GLenum type
,
63 const struct gl_pixelstore_attrib
*packing
,
66 struct gl_framebuffer
*fb
= ctx
->ReadBuffer
;
67 struct pipe_screen
*screen
= ctx
->st
->pipe
->screen
;
68 struct st_renderbuffer
*strb
= st_renderbuffer(fb
->_StencilBuffer
);
69 struct pipe_transfer
*pt
;
73 if (st_fb_orientation(ctx
->DrawBuffer
) == Y_0_TOP
) {
74 y
= ctx
->DrawBuffer
->Height
- y
- height
;
77 /* Create a read transfer from the renderbuffer's texture */
79 pt
= st_cond_flush_get_tex_transfer(st_context(ctx
), strb
->texture
,
81 PIPE_TRANSFER_READ
, x
, y
,
84 /* map the stencil buffer */
85 stmap
= screen
->transfer_map(screen
, pt
);
87 /* width should never be > MAX_WIDTH since we did clipping earlier */
88 ASSERT(width
<= MAX_WIDTH
);
90 /* process image row by row */
91 for (j
= 0; j
< height
; j
++) {
93 GLstencil sValues
[MAX_WIDTH
];
94 GLfloat zValues
[MAX_WIDTH
];
97 if (st_fb_orientation(ctx
->DrawBuffer
) == Y_0_TOP
) {
98 srcY
= height
- j
- 1;
104 /* get stencil (and Z) values */
105 switch (pt
->format
) {
106 case PIPE_FORMAT_S8_UNORM
:
108 const ubyte
*src
= stmap
+ srcY
* pt
->stride
;
109 memcpy(sValues
, src
, width
);
112 case PIPE_FORMAT_S8Z24_UNORM
:
113 if (format
== GL_DEPTH_STENCIL
) {
114 const uint
*src
= (uint
*) (stmap
+ srcY
* pt
->stride
);
115 const GLfloat scale
= 1.0f
/ (0xffffff);
117 for (k
= 0; k
< width
; k
++) {
118 sValues
[k
] = src
[k
] >> 24;
119 zValues
[k
] = (src
[k
] & 0xffffff) * scale
;
123 const uint
*src
= (uint
*) (stmap
+ srcY
* pt
->stride
);
125 for (k
= 0; k
< width
; k
++) {
126 sValues
[k
] = src
[k
] >> 24;
130 case PIPE_FORMAT_Z24S8_UNORM
:
131 if (format
== GL_DEPTH_STENCIL
) {
132 const uint
*src
= (uint
*) (stmap
+ srcY
* pt
->stride
);
133 const GLfloat scale
= 1.0f
/ (0xffffff);
135 for (k
= 0; k
< width
; k
++) {
136 sValues
[k
] = src
[k
] & 0xff;
137 zValues
[k
] = (src
[k
] >> 8) * scale
;
141 const uint
*src
= (uint
*) (stmap
+ srcY
* pt
->stride
);
143 for (k
= 0; k
< width
; k
++) {
144 sValues
[k
] = src
[k
] & 0xff;
153 dest
= _mesa_image_address2d(packing
, pixels
, width
, height
,
155 if (format
== GL_DEPTH_STENCIL
) {
156 _mesa_pack_depth_stencil_span(ctx
, width
, dest
,
157 zValues
, sValues
, packing
);
160 _mesa_pack_stencil_span(ctx
, width
, type
, dest
, sValues
, packing
);
164 /* unmap the stencil buffer */
165 screen
->transfer_unmap(screen
, pt
);
166 screen
->tex_transfer_destroy(pt
);
171 * Return renderbuffer to use for reading color pixels for glRead/CopyPixel
173 * Special care is needed for the front buffer.
175 struct st_renderbuffer
*
176 st_get_color_read_renderbuffer(GLcontext
*ctx
)
178 struct gl_framebuffer
*fb
= ctx
->ReadBuffer
;
179 struct st_renderbuffer
*strb
=
180 st_renderbuffer(fb
->_ColorReadBuffer
);
181 struct st_renderbuffer
*front
=
182 st_renderbuffer(fb
->Attachment
[BUFFER_FRONT_LEFT
].Renderbuffer
);
185 && ctx
->st
->frontbuffer_status
== FRONT_STATUS_COPY_OF_BACK
) {
186 /* reading from front color buffer, which is a logical copy of the
189 struct st_renderbuffer
*back
=
190 st_renderbuffer(fb
->Attachment
[BUFFER_BACK_LEFT
].Renderbuffer
);
199 * Try to do glReadPixels in a fast manner for common cases.
200 * \return GL_TRUE for success, GL_FALSE for failure
203 st_fast_readpixels(GLcontext
*ctx
, struct st_renderbuffer
*strb
,
204 GLint x
, GLint y
, GLsizei width
, GLsizei height
,
205 GLenum format
, GLenum type
,
206 const struct gl_pixelstore_attrib
*pack
,
210 A8R8G8B8_UNORM_TO_RGBA_UBYTE
,
211 A8R8G8B8_UNORM_TO_RGB_UBYTE
,
212 A8R8G8B8_UNORM_TO_BGRA_UINT
215 if (ctx
->_ImageTransferState
)
218 if (strb
->format
== PIPE_FORMAT_A8R8G8B8_UNORM
&&
219 format
== GL_RGBA
&& type
== GL_UNSIGNED_BYTE
) {
220 combo
= A8R8G8B8_UNORM_TO_RGBA_UBYTE
;
222 else if (strb
->format
== PIPE_FORMAT_A8R8G8B8_UNORM
&&
223 format
== GL_RGB
&& type
== GL_UNSIGNED_BYTE
) {
224 combo
= A8R8G8B8_UNORM_TO_RGB_UBYTE
;
226 else if (strb
->format
== PIPE_FORMAT_A8R8G8B8_UNORM
&&
227 format
== GL_BGRA
&& type
== GL_UNSIGNED_INT_8_8_8_8_REV
) {
228 combo
= A8R8G8B8_UNORM_TO_BGRA_UINT
;
234 /*printf("st_fast_readpixels combo %d\n", (GLint) combo);*/
237 struct pipe_context
*pipe
= ctx
->st
->pipe
;
238 struct pipe_screen
*screen
= pipe
->screen
;
239 struct pipe_transfer
*trans
;
242 GLint row
, col
, dy
, dstStride
;
244 if (st_fb_orientation(ctx
->ReadBuffer
) == Y_0_TOP
) {
245 y
= strb
->texture
->height
[0] - y
- height
;
248 trans
= st_cond_flush_get_tex_transfer(st_context(ctx
), strb
->texture
,
250 PIPE_TRANSFER_READ
, x
, y
,
256 map
= screen
->transfer_map(screen
, trans
);
258 screen
->tex_transfer_destroy(trans
);
262 if (st_fb_orientation(ctx
->ReadBuffer
) == Y_0_TOP
) {
271 dst
= _mesa_image_address2d(pack
, dest
, width
, height
,
273 dstStride
= _mesa_image_row_stride(pack
, width
, format
, type
);
276 case A8R8G8B8_UNORM_TO_RGBA_UBYTE
:
277 for (row
= 0; row
< height
; row
++) {
278 const GLubyte
*src
= map
+ y
* trans
->stride
;
279 for (col
= 0; col
< width
; col
++) {
280 GLuint pixel
= ((GLuint
*) src
)[col
];
281 dst
[col
*4+0] = (pixel
>> 16) & 0xff;
282 dst
[col
*4+1] = (pixel
>> 8) & 0xff;
283 dst
[col
*4+2] = (pixel
>> 0) & 0xff;
284 dst
[col
*4+3] = (pixel
>> 24) & 0xff;
290 case A8R8G8B8_UNORM_TO_RGB_UBYTE
:
291 for (row
= 0; row
< height
; row
++) {
292 const GLubyte
*src
= map
+ y
* trans
->stride
;
293 for (col
= 0; col
< width
; col
++) {
294 GLuint pixel
= ((GLuint
*) src
)[col
];
295 dst
[col
*3+0] = (pixel
>> 16) & 0xff;
296 dst
[col
*3+1] = (pixel
>> 8) & 0xff;
297 dst
[col
*3+2] = (pixel
>> 0) & 0xff;
303 case A8R8G8B8_UNORM_TO_BGRA_UINT
:
304 for (row
= 0; row
< height
; row
++) {
305 const GLubyte
*src
= map
+ y
* trans
->stride
;
306 memcpy(dst
, src
, 4 * width
);
315 screen
->transfer_unmap(screen
, trans
);
316 screen
->tex_transfer_destroy(trans
);
324 * Do glReadPixels by getting rows from the framebuffer transfer with
325 * get_tile(). Convert to requested format/type with Mesa image routines.
326 * Image transfer ops are done in software too.
329 st_readpixels(GLcontext
*ctx
, GLint x
, GLint y
, GLsizei width
, GLsizei height
,
330 GLenum format
, GLenum type
,
331 const struct gl_pixelstore_attrib
*pack
,
334 struct pipe_context
*pipe
= ctx
->st
->pipe
;
335 struct pipe_screen
*screen
= pipe
->screen
;
336 GLfloat temp
[MAX_WIDTH
][4];
337 const GLbitfield transferOps
= ctx
->_ImageTransferState
;
339 GLint yStep
, dfStride
;
341 struct st_renderbuffer
*strb
;
342 struct gl_pixelstore_attrib clippedPacking
= *pack
;
343 struct pipe_transfer
*trans
;
345 assert(ctx
->ReadBuffer
->Width
> 0);
347 /* XXX convolution not done yet */
348 assert((transferOps
& IMAGE_CONVOLUTION_BIT
) == 0);
350 /* Do all needed clipping here, so that we can forget about it later */
351 if (!_mesa_clip_readpixels(ctx
, &x
, &y
, &width
, &height
, &clippedPacking
)) {
352 /* The ReadPixels transfer is totally outside the window bounds */
356 dest
= _mesa_map_pbo_dest(ctx
, &clippedPacking
, dest
);
360 st_flush(ctx
->st
, PIPE_FLUSH_RENDER_CACHE
, NULL
);
362 if (format
== GL_STENCIL_INDEX
||
363 format
== GL_DEPTH_STENCIL
) {
364 st_read_stencil_pixels(ctx
, x
, y
, width
, height
,
365 format
, type
, pack
, dest
);
368 else if (format
== GL_DEPTH_COMPONENT
) {
369 strb
= st_renderbuffer(ctx
->ReadBuffer
->_DepthBuffer
);
372 /* Read color buffer */
373 strb
= st_get_color_read_renderbuffer(ctx
);
379 /* try a fast-path readpixels before anything else */
380 if (st_fast_readpixels(ctx
, strb
, x
, y
, width
, height
,
381 format
, type
, pack
, dest
)) {
383 _mesa_unmap_pbo_dest(ctx
, &clippedPacking
);
387 if (format
== GL_RGBA
&& type
== GL_FLOAT
) {
388 /* write tile(row) directly into user's buffer */
389 df
= (GLfloat
*) _mesa_image_address2d(&clippedPacking
, dest
, width
,
390 height
, format
, type
, 0, 0);
391 dfStride
= width
* 4;
394 /* write tile(row) into temp row buffer */
395 df
= (GLfloat
*) temp
;
399 if (st_fb_orientation(ctx
->ReadBuffer
) == Y_0_TOP
) {
400 y
= strb
->Base
.Height
- y
- height
;
403 /* Create a read transfer from the renderbuffer's texture */
404 trans
= st_cond_flush_get_tex_transfer(st_context(ctx
), strb
->texture
,
406 PIPE_TRANSFER_READ
, x
, y
,
409 /* determine bottom-to-top vs. top-to-bottom order */
410 if (st_fb_orientation(ctx
->ReadBuffer
) == Y_0_TOP
) {
420 * Copy pixels from pipe_transfer to user memory
423 /* dest of first pixel in client memory */
424 GLubyte
*dst
= _mesa_image_address2d(&clippedPacking
, dest
, width
,
425 height
, format
, type
, 0, 0);
426 /* dest row stride */
427 const GLint dstStride
= _mesa_image_row_stride(&clippedPacking
, width
,
430 if (trans
->format
== PIPE_FORMAT_S8Z24_UNORM
||
431 trans
->format
== PIPE_FORMAT_X8Z24_UNORM
) {
432 if (format
== GL_DEPTH_COMPONENT
) {
433 for (i
= 0; i
< height
; i
++) {
434 GLuint ztemp
[MAX_WIDTH
];
435 GLfloat zfloat
[MAX_WIDTH
];
436 const double scale
= 1.0 / ((1 << 24) - 1);
437 pipe_get_tile_raw(trans
, 0, y
, width
, 1, ztemp
, 0);
439 for (j
= 0; j
< width
; j
++) {
440 zfloat
[j
] = (float) (scale
* (ztemp
[j
] & 0xffffff));
442 _mesa_pack_depth_span(ctx
, width
, dst
, type
,
443 zfloat
, &clippedPacking
);
448 /* XXX: unreachable code -- should be before st_read_stencil_pixels */
449 assert(format
== GL_DEPTH_STENCIL_EXT
);
450 for (i
= 0; i
< height
; i
++) {
451 GLuint
*zshort
= (GLuint
*)dst
;
452 pipe_get_tile_raw(trans
, 0, y
, width
, 1, dst
, 0);
454 /* Reverse into 24/8 */
455 for (j
= 0; j
< width
; j
++) {
456 zshort
[j
] = (zshort
[j
] << 8) | (zshort
[j
] >> 24);
462 else if (trans
->format
== PIPE_FORMAT_Z24S8_UNORM
||
463 trans
->format
== PIPE_FORMAT_Z24X8_UNORM
) {
464 if (format
== GL_DEPTH_COMPONENT
) {
465 for (i
= 0; i
< height
; i
++) {
466 GLuint ztemp
[MAX_WIDTH
];
467 GLfloat zfloat
[MAX_WIDTH
];
468 const double scale
= 1.0 / ((1 << 24) - 1);
469 pipe_get_tile_raw(trans
, 0, y
, width
, 1, ztemp
, 0);
471 for (j
= 0; j
< width
; j
++) {
472 zfloat
[j
] = (float) (scale
* ((ztemp
[j
] >> 8) & 0xffffff));
474 _mesa_pack_depth_span(ctx
, width
, dst
, type
,
475 zfloat
, &clippedPacking
);
480 /* XXX: unreachable code -- should be before st_read_stencil_pixels */
481 assert(format
== GL_DEPTH_STENCIL_EXT
);
482 for (i
= 0; i
< height
; i
++) {
483 pipe_get_tile_raw(trans
, 0, y
, width
, 1, dst
, 0);
489 else if (trans
->format
== PIPE_FORMAT_Z16_UNORM
) {
490 for (i
= 0; i
< height
; i
++) {
491 GLushort ztemp
[MAX_WIDTH
];
492 GLfloat zfloat
[MAX_WIDTH
];
493 const double scale
= 1.0 / 0xffff;
494 pipe_get_tile_raw(trans
, 0, y
, width
, 1, ztemp
, 0);
496 for (j
= 0; j
< width
; j
++) {
497 zfloat
[j
] = (float) (scale
* ztemp
[j
]);
499 _mesa_pack_depth_span(ctx
, width
, dst
, type
,
500 zfloat
, &clippedPacking
);
504 else if (trans
->format
== PIPE_FORMAT_Z32_UNORM
) {
505 for (i
= 0; i
< height
; i
++) {
506 GLuint ztemp
[MAX_WIDTH
];
507 GLfloat zfloat
[MAX_WIDTH
];
508 const double scale
= 1.0 / 0xffffffff;
509 pipe_get_tile_raw(trans
, 0, y
, width
, 1, ztemp
, 0);
511 for (j
= 0; j
< width
; j
++) {
512 zfloat
[j
] = (float) (scale
* ztemp
[j
]);
514 _mesa_pack_depth_span(ctx
, width
, dst
, type
,
515 zfloat
, &clippedPacking
);
521 /* Do a row at a time to flip image data vertically */
522 for (i
= 0; i
< height
; i
++) {
523 pipe_get_tile_rgba(trans
, 0, y
, width
, 1, df
);
527 _mesa_pack_rgba_span_float(ctx
, width
, temp
, format
, type
, dst
,
528 &clippedPacking
, transferOps
);
535 screen
->tex_transfer_destroy(trans
);
537 _mesa_unmap_pbo_dest(ctx
, &clippedPacking
);
541 void st_init_readpixels_functions(struct dd_function_table
*functions
)
543 functions
->ReadPixels
= st_readpixels
;