OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e50dd26ca6d0eb0d0f97c2780020ea16e3d4a687
third_party_mesa3d/src/mesa/state_tracker/st_cb_readpixels.c
Thomas Hellstrom e50dd26ca6 gallium: Create OGL state tracker wrappers for various CPU access operations. 
There are two usage types of buffer CPU accesses:
One where we try to use the buffer contents for multiple draw commands in
a batch. (batch := sequence of commands that are flushed together),
like incrementally adding bitmaps to a bitmap texture that is reallocated
on flush.
And one where we assume we can safely overwrite the old buffer contexts, like
glTexSubImage. In this case we need to make sure all old drawing commands
referencing the buffer are flushed before we map the buffer.
This is easily forgotten.

Add wrappers for the most common of these operations. The first type is
prefixed with "st_no_flush" and the second type is prefixed with
"st_cond_flush", where "cond" indicates that we attmpt to only flush
if there is indeed unflushed draw commands referencing the buffer.

Prefixed functions are
screen::get_tex_transfer
pipe_buffer_write
pipe_buffer_read
pipe_buffer_map

Please use the wrappers whenever possible.

Signed-off-by: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
2009-04-17 13:18:05 +02:00

538 lines
17 KiB
C
Raw Blame History

/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
/**
* glReadPixels interface to pipe
*
* \author Brian Paul
*/
#include "main/imports.h"
#include "main/bufferobj.h"
#include "main/context.h"
#include "main/image.h"
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_inlines.h"
#include "util/u_tile.h"
#include "st_context.h"
#include "st_cb_bitmap.h"
#include "st_cb_readpixels.h"
#include "st_cb_fbo.h"
#include "st_format.h"
#include "st_public.h"
#include "st_texture.h"
#include "st_inlines.h"
/**
* Special case for reading stencil buffer.
* For color/depth we use get_tile(). For stencil, map the stencil buffer.
*/
void
st_read_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
GLsizei width, GLsizei height,
GLenum format, GLenum type,
const struct gl_pixelstore_attrib *packing,
GLvoid *pixels)
{
struct gl_framebuffer *fb = ctx->ReadBuffer;
struct pipe_screen *screen = ctx->st->pipe->screen;
struct st_renderbuffer *strb = st_renderbuffer(fb->_StencilBuffer);
struct pipe_transfer *pt;
ubyte *stmap;
GLint j;
if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
y = ctx->DrawBuffer->Height - y - height;
}
/* Create a read transfer from the renderbuffer's texture */
pt = st_cond_flush_get_tex_transfer(st_context(ctx), strb->texture,
0, 0, 0,
PIPE_TRANSFER_READ, x, y,
width, height);
/* map the stencil buffer */
stmap = screen->transfer_map(screen, pt);
/* width should never be > MAX_WIDTH since we did clipping earlier */
ASSERT(width <= MAX_WIDTH);
/* process image row by row */
for (j = 0; j < height; j++) {
GLvoid *dest;
GLstencil sValues[MAX_WIDTH];
GLfloat zValues[MAX_WIDTH];
GLint srcY;
if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
srcY = height - j - 1;
}
else {
srcY = j;
}
/* get stencil (and Z) values */
switch (pt->format) {
case PIPE_FORMAT_S8_UNORM:
{
const ubyte *src = stmap + srcY * pt->stride;
memcpy(sValues, src, width);
}
break;
case PIPE_FORMAT_S8Z24_UNORM:
if (format == GL_DEPTH_STENCIL) {
const uint *src = (uint *) (stmap + srcY * pt->stride);
const GLfloat scale = 1.0 / (0xffffff);
GLint k;
for (k = 0; k < width; k++) {
sValues[k] = src[k] >> 24;
zValues[k] = (src[k] & 0xffffff) * scale;
}
}
else {
const uint *src = (uint *) (stmap + srcY * pt->stride);
GLint k;
for (k = 0; k < width; k++) {
sValues[k] = src[k] >> 24;
}
}
break;
case PIPE_FORMAT_Z24S8_UNORM:
if (format == GL_DEPTH_STENCIL) {
const uint *src = (uint *) (stmap + srcY * pt->stride);
const GLfloat scale = 1.0 / (0xffffff);
GLint k;
for (k = 0; k < width; k++) {
sValues[k] = src[k] & 0xff;
zValues[k] = (src[k] >> 8) * scale;
}
}
else {
const uint *src = (uint *) (stmap + srcY * pt->stride);
GLint k;
for (k = 0; k < width; k++) {
sValues[k] = src[k] & 0xff;
}
}
break;
default:
assert(0);
}
/* store */
dest = _mesa_image_address2d(packing, pixels, width, height,
format, type, j, 0);
if (format == GL_DEPTH_STENCIL) {
_mesa_pack_depth_stencil_span(ctx, width, dest,
zValues, sValues, packing);
}
else {
_mesa_pack_stencil_span(ctx, width, type, dest, sValues, packing);
}
}
/* unmap the stencil buffer */
screen->transfer_unmap(screen, pt);
screen->tex_transfer_destroy(pt);
}
/**
* Return renderbuffer to use for reading color pixels for glRead/CopyPixel
* commands.
* Special care is needed for the front buffer.
*/
struct st_renderbuffer *
st_get_color_read_renderbuffer(GLcontext *ctx)
{
struct gl_framebuffer *fb = ctx->ReadBuffer;
struct st_renderbuffer *strb =
st_renderbuffer(fb->_ColorReadBuffer);
struct st_renderbuffer *front =
st_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
if (strb == front
&& ctx->st->frontbuffer_status == FRONT_STATUS_COPY_OF_BACK) {
/* reading from front color buffer, which is a logical copy of the
* back color buffer.
*/
struct st_renderbuffer *back =
st_renderbuffer(fb->Attachment[BUFFER_BACK_LEFT].Renderbuffer);
strb = back;
}
return strb;
}
/**
* Try to do glReadPixels in a fast manner for common cases.
* \return GL_TRUE for success, GL_FALSE for failure
*/
static GLboolean
st_fast_readpixels(GLcontext *ctx, struct st_renderbuffer *strb,
GLint x, GLint y, GLsizei width, GLsizei height,
GLenum format, GLenum type,
const struct gl_pixelstore_attrib *pack,
GLvoid *dest)
{
enum combination {
A8R8G8B8_UNORM_TO_RGBA_UBYTE,
A8R8G8B8_UNORM_TO_RGB_UBYTE,
A8R8G8B8_UNORM_TO_BGRA_UINT
} combo;
if (ctx->_ImageTransferState)
return GL_FALSE;
if (strb->format == PIPE_FORMAT_A8R8G8B8_UNORM &&
format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
combo = A8R8G8B8_UNORM_TO_RGBA_UBYTE;
}
else if (strb->format == PIPE_FORMAT_A8R8G8B8_UNORM &&
format == GL_RGB && type == GL_UNSIGNED_BYTE) {
combo = A8R8G8B8_UNORM_TO_RGB_UBYTE;
}
else if (strb->format == PIPE_FORMAT_A8R8G8B8_UNORM &&
format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV) {
combo = A8R8G8B8_UNORM_TO_BGRA_UINT;
}
else {
return GL_FALSE;
}
/*printf("st_fast_readpixels combo %d\n", (GLint) combo);*/
{
struct pipe_context *pipe = ctx->st->pipe;
struct pipe_screen *screen = pipe->screen;
struct pipe_transfer *trans;
const GLubyte *map;
GLubyte *dst;
GLint row, col, dy, dstStride;
if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
y = strb->texture->height[0] - y - height;
}
trans = st_cond_flush_get_tex_transfer(st_context(ctx), strb->texture,
0, 0, 0,
PIPE_TRANSFER_READ, x, y,
width, height);
if (!trans) {
return GL_FALSE;
}
map = screen->transfer_map(screen, trans);
if (!map) {
screen->tex_transfer_destroy(trans);
return GL_FALSE;
}
if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
y = height - 1;
dy = -1;
}
else {
y = 0;
dy = 1;
}
dst = _mesa_image_address2d(pack, dest, width, height,
format, type, 0, 0);
dstStride = _mesa_image_row_stride(pack, width, format, type);
switch (combo) {
case A8R8G8B8_UNORM_TO_RGBA_UBYTE:
for (row = 0; row < height; row++) {
const GLubyte *src = map + y * trans->stride;
for (col = 0; col < width; col++) {
GLuint pixel = ((GLuint *) src)[col];
dst[col*4+0] = (pixel >> 16) & 0xff;
dst[col*4+1] = (pixel >> 8) & 0xff;
dst[col*4+2] = (pixel >> 0) & 0xff;
dst[col*4+3] = (pixel >> 24) & 0xff;
}
dst += dstStride;
y += dy;
}
break;
case A8R8G8B8_UNORM_TO_RGB_UBYTE:
for (row = 0; row < height; row++) {
const GLubyte *src = map + y * trans->stride;
for (col = 0; col < width; col++) {
GLuint pixel = ((GLuint *) src)[col];
dst[col*3+0] = (pixel >> 16) & 0xff;
dst[col*3+1] = (pixel >> 8) & 0xff;
dst[col*3+2] = (pixel >> 0) & 0xff;
}
dst += dstStride;
y += dy;
}
break;
case A8R8G8B8_UNORM_TO_BGRA_UINT:
for (row = 0; row < height; row++) {
const GLubyte *src = map + y * trans->stride;
memcpy(dst, src, 4 * width);
dst += dstStride;
y += dy;
}
break;
default:
; /* nothing */
}
screen->transfer_unmap(screen, trans);
screen->tex_transfer_destroy(trans);
}
return GL_TRUE;
}
/**
* Do glReadPixels by getting rows from the framebuffer transfer with
* get_tile(). Convert to requested format/type with Mesa image routines.
* Image transfer ops are done in software too.
*/
static void
st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
GLenum format, GLenum type,
const struct gl_pixelstore_attrib *pack,
GLvoid *dest)
{
struct pipe_context *pipe = ctx->st->pipe;
struct pipe_screen *screen = pipe->screen;
GLfloat temp[MAX_WIDTH][4];
const GLbitfield transferOps = ctx->_ImageTransferState;
GLsizei i, j;
GLint yStep, dfStride;
GLfloat *df;
struct st_renderbuffer *strb;
struct gl_pixelstore_attrib clippedPacking = *pack;
struct pipe_transfer *trans;
assert(ctx->ReadBuffer->Width > 0);
/* XXX convolution not done yet */
assert((transferOps & IMAGE_CONVOLUTION_BIT) == 0);
/* Do all needed clipping here, so that we can forget about it later */
if (!_mesa_clip_readpixels(ctx, &x, &y, &width, &height, &clippedPacking)) {
/* The ReadPixels transfer is totally outside the window bounds */
return;
}
dest = _mesa_map_readpix_pbo(ctx, &clippedPacking, dest);
if (!dest)
return;
if (format == GL_STENCIL_INDEX ||
format == GL_DEPTH_STENCIL) {
st_read_stencil_pixels(ctx, x, y, width, height,
format, type, pack, dest);
return;
}
else if (format == GL_DEPTH_COMPONENT) {
strb = st_renderbuffer(ctx->ReadBuffer->_DepthBuffer);
}
else {
/* Read color buffer */
strb = st_get_color_read_renderbuffer(ctx);
}
if (!strb)
return;
/* try a fast-path readpixels before anything else */
if (st_fast_readpixels(ctx, strb, x, y, width, height,
format, type, pack, dest)) {
/* success! */
_mesa_unmap_readpix_pbo(ctx, &clippedPacking);
return;
}
if (format == GL_RGBA && type == GL_FLOAT) {
/* write tile(row) directly into user's buffer */
df = (GLfloat *) _mesa_image_address2d(&clippedPacking, dest, width,
height, format, type, 0, 0);
dfStride = width * 4;
}
else {
/* write tile(row) into temp row buffer */
df = (GLfloat *) temp;
dfStride = 0;
}
if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
y = strb->Base.Height - y - height;
}
/* Create a read transfer from the renderbuffer's texture */
trans = st_cond_flush_get_tex_transfer(st_context(ctx), strb->texture,
0, 0, 0,
PIPE_TRANSFER_READ, x, y,
width, height);
/* determine bottom-to-top vs. top-to-bottom order */
if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
y = height - 1;
yStep = -1;
}
else {
y = 0;
yStep = 1;
}
/*
* Copy pixels from pipe_transfer to user memory
*/
{
/* dest of first pixel in client memory */
GLubyte *dst = _mesa_image_address2d(&clippedPacking, dest, width,
height, format, type, 0, 0);
/* dest row stride */
const GLint dstStride = _mesa_image_row_stride(&clippedPacking, width,
format, type);
if (trans->format == PIPE_FORMAT_S8Z24_UNORM ||
trans->format == PIPE_FORMAT_X8Z24_UNORM) {
if (format == GL_DEPTH_COMPONENT) {
for (i = 0; i < height; i++) {
GLuint ztemp[MAX_WIDTH];
GLfloat zfloat[MAX_WIDTH];
const double scale = 1.0 / ((1 << 24) - 1);
pipe_get_tile_raw(trans, 0, y, width, 1, ztemp, 0);
y += yStep;
for (j = 0; j < width; j++) {
zfloat[j] = (float) (scale * (ztemp[j] & 0xffffff));
}
_mesa_pack_depth_span(ctx, width, dst, type,
zfloat, &clippedPacking);
dst += dstStride;
}
}
else {
/* untested, but simple: */
assert(format == GL_DEPTH_STENCIL_EXT);
for (i = 0; i < height; i++) {
pipe_get_tile_raw(trans, 0, y, width, 1, dst, 0);
y += yStep;
dst += dstStride;
}
}
}
else if (trans->format == PIPE_FORMAT_Z24S8_UNORM ||
trans->format == PIPE_FORMAT_Z24X8_UNORM) {
if (format == GL_DEPTH_COMPONENT) {
for (i = 0; i < height; i++) {
GLuint ztemp[MAX_WIDTH];
GLfloat zfloat[MAX_WIDTH];
const double scale = 1.0 / ((1 << 24) - 1);
pipe_get_tile_raw(trans, 0, y, width, 1, ztemp, 0);
y += yStep;
for (j = 0; j < width; j++) {
zfloat[j] = (float) (scale * ((ztemp[j] >> 8) & 0xffffff));
}
_mesa_pack_depth_span(ctx, width, dst, type,
zfloat, &clippedPacking);
dst += dstStride;
}
}
else {
/* untested, but simple: */
assert(format == GL_DEPTH_STENCIL_EXT);
for (i = 0; i < height; i++) {
pipe_get_tile_raw(trans, 0, y, width, 1, dst, 0);
y += yStep;
dst += dstStride;
}
}
}
else if (trans->format == PIPE_FORMAT_Z16_UNORM) {
for (i = 0; i < height; i++) {
GLushort ztemp[MAX_WIDTH];
GLfloat zfloat[MAX_WIDTH];
const double scale = 1.0 / 0xffff;
pipe_get_tile_raw(trans, 0, y, width, 1, ztemp, 0);
y += yStep;
for (j = 0; j < width; j++) {
zfloat[j] = (float) (scale * ztemp[j]);
}
_mesa_pack_depth_span(ctx, width, dst, type,
zfloat, &clippedPacking);
dst += dstStride;
}
}
else if (trans->format == PIPE_FORMAT_Z32_UNORM) {
for (i = 0; i < height; i++) {
GLuint ztemp[MAX_WIDTH];
GLfloat zfloat[MAX_WIDTH];
const double scale = 1.0 / 0xffffffff;
pipe_get_tile_raw(trans, 0, y, width, 1, ztemp, 0);
y += yStep;
for (j = 0; j < width; j++) {
zfloat[j] = (float) (scale * ztemp[j]);
}
_mesa_pack_depth_span(ctx, width, dst, type,
zfloat, &clippedPacking);
dst += dstStride;
}
}
else {
/* RGBA format */
/* Do a row at a time to flip image data vertically */
for (i = 0; i < height; i++) {
pipe_get_tile_rgba(trans, 0, y, width, 1, df);
y += yStep;
df += dfStride;
if (!dfStride) {
_mesa_pack_rgba_span_float(ctx, width, temp, format, type, dst,
&clippedPacking, transferOps);
dst += dstStride;
}
}
}
}
screen->tex_transfer_destroy(trans);
_mesa_unmap_readpix_pbo(ctx, &clippedPacking);
}
void st_init_readpixels_functions(struct dd_function_table *functions)
{
functions->ReadPixels = st_readpixels;
}
Reference in New Issue View Git Blame Copy Permalink