/**
* glGetTexImage for depth/Z pixels.
*/
static void
get_tex_depth(GLcontext *ctx, GLuint dimensions,
GLenum format, GLenum type, GLvoid *pixels,
const struct gl_texture_image *texImage)
{
const GLint width = texImage->Width;
const GLint height = texImage->Height;
const GLint depth = texImage->Depth;
GLint img, row, col;
for (img = 0; img < depth; img++) {
for (row = 0; row < height; row++) {
GLfloat depthRow[MAX_WIDTH];
void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,
width, height, format, type,
img, row, 0);
assert(dest);
for (col = 0; col < width; col++) {
texImage->FetchTexelf(texImage, col, row, img, depthRow + col);
}
_mesa_pack_depth_span(ctx, width, dest, type, depthRow, &ctx->Pack);
}
}
}
/**
* Read pixels for format=GL_DEPTH_COMPONENT.
*/
static void
read_depth_pixels( struct gl_context *ctx,
GLint x, GLint y,
GLsizei width, GLsizei height,
GLenum type, GLvoid *pixels,
const struct gl_pixelstore_attrib *packing )
{
struct gl_framebuffer *fb = ctx->ReadBuffer;
struct gl_renderbuffer *rb = fb->Attachment[BUFFER_DEPTH].Renderbuffer;
GLint j;
GLubyte *dst, *map;
int dstStride, stride;
GLfloat *depthValues;
if (!rb)
return;
/* clipping should have been done already */
ASSERT(x >= 0);
ASSERT(y >= 0);
ASSERT(x + width <= (GLint) rb->Width);
ASSERT(y + height <= (GLint) rb->Height);
if (type == GL_UNSIGNED_INT &&
read_uint_depth_pixels(ctx, x, y, width, height, type, pixels, packing)) {
return;
}
dstStride = _mesa_image_row_stride(packing, width, GL_DEPTH_COMPONENT, type);
dst = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,
GL_DEPTH_COMPONENT, type, 0, 0);
ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT,
&map, &stride);
if (!map) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
return;
}
depthValues = malloc(width * sizeof(GLfloat));
if (depthValues) {
/* General case (slower) */
for (j = 0; j < height; j++, y++) {
_mesa_unpack_float_z_row(rb->Format, width, map, depthValues);
_mesa_pack_depth_span(ctx, width, dst, type, depthValues, packing);
dst += dstStride;
map += stride;
}
}
else {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
}
free(depthValues);
ctx->Driver.UnmapRenderbuffer(ctx, rb);
}
/**
* glGetTexImage for depth/Z pixels.
*/
static void
get_tex_depth(struct gl_context *ctx, GLuint dimensions,
GLenum format, GLenum type, GLvoid *pixels,
struct gl_texture_image *texImage)
{
const GLint width = texImage->Width;
GLint height = texImage->Height;
GLint depth = texImage->Depth;
GLint img, row;
GLfloat *depthRow = malloc(width * sizeof(GLfloat));
if (!depthRow) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage");
return;
}
if (texImage->TexObject->Target == GL_TEXTURE_1D_ARRAY) {
depth = height;
height = 1;
}
for (img = 0; img < depth; img++) {
GLubyte *srcMap;
GLint srcRowStride;
/* map src texture buffer */
ctx->Driver.MapTextureImage(ctx, texImage, img,
0, 0, width, height, GL_MAP_READ_BIT,
&srcMap, &srcRowStride);
if (srcMap) {
for (row = 0; row < height; row++) {
void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,
width, height, format, type,
img, row, 0);
const GLubyte *src = srcMap + row * srcRowStride;
// _mesa_unpack_float_z_row(texImage->TexFormat, width, src, depthRow);
_mesa_pack_depth_span(ctx, width, dest, type, depthRow, &ctx->Pack);
}
ctx->Driver.UnmapTextureImage(ctx, texImage, img);
}
else {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage");
break;
}
}
free(depthRow);
}
/**
* This is the software fallback for Driver.GetTexImage().
* All error checking will have been done before this routine is called.
*/
void
_mesa_get_teximage(GLcontext *ctx, GLenum target, GLint level,
GLenum format, GLenum type, GLvoid *pixels,
struct gl_texture_object *texObj,
struct gl_texture_image *texImage)
{
const GLuint dimensions = (target == GL_TEXTURE_3D) ? 3 : 2;
if (ctx->Pack.BufferObj->Name) {
/* Packing texture image into a PBO.
* Map the (potentially) VRAM-based buffer into our process space so
* we can write into it with the code below.
* A hardware driver might use a sophisticated blit to move the
* texture data to the PBO if the PBO is in VRAM along with the texture.
*/
GLubyte *buf = (GLubyte *)
ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
GL_WRITE_ONLY_ARB, ctx->Pack.BufferObj);
if (!buf) {
/* buffer is already mapped - that's an error */
_mesa_error(ctx, GL_INVALID_OPERATION,"glGetTexImage(PBO is mapped)");
return;
}
/* <pixels> was an offset into the PBO.
* Now make it a real, client-side pointer inside the mapped region.
*/
pixels = ADD_POINTERS(buf, pixels);
}
else if (!pixels) {
/* not an error */
return;
}
{
const GLint width = texImage->Width;
const GLint height = texImage->Height;
const GLint depth = texImage->Depth;
GLint img, row;
for (img = 0; img < depth; img++) {
for (row = 0; row < height; row++) {
/* compute destination address in client memory */
GLvoid *dest = _mesa_image_address( dimensions, &ctx->Pack, pixels,
width, height, format, type,
img, row, 0);
assert(dest);
if (format == GL_COLOR_INDEX) {
GLuint indexRow[MAX_WIDTH];
GLint col;
/* Can't use FetchTexel here because that returns RGBA */
if (texImage->TexFormat->IndexBits == 8) {
const GLubyte *src = (const GLubyte *) texImage->Data;
src += width * (img * texImage->Height + row);
for (col = 0; col < width; col++) {
indexRow[col] = src[col];
}
}
else if (texImage->TexFormat->IndexBits == 16) {
const GLushort *src = (const GLushort *) texImage->Data;
src += width * (img * texImage->Height + row);
for (col = 0; col < width; col++) {
indexRow[col] = src[col];
}
}
else {
_mesa_problem(ctx,
"Color index problem in _mesa_GetTexImage");
}
_mesa_pack_index_span(ctx, width, type, dest,
indexRow, &ctx->Pack,
0 /* no image transfer */);
}
else if (format == GL_DEPTH_COMPONENT) {
GLfloat depthRow[MAX_WIDTH];
GLint col;
for (col = 0; col < width; col++) {
(*texImage->FetchTexelf)(texImage, col, row, img,
depthRow + col);
}
_mesa_pack_depth_span(ctx, width, dest, type,
depthRow, &ctx->Pack);
}
else if (format == GL_DEPTH_STENCIL_EXT) {
/* XXX Note: we're bypassing texImage->FetchTexel()! */
const GLuint *src = (const GLuint *) texImage->Data;
src += width * row + width * height * img;
_mesa_memcpy(dest, src, width * sizeof(GLuint));
if (ctx->Pack.SwapBytes) {
_mesa_swap4((GLuint *) dest, width);
}
}
else if (format == GL_YCBCR_MESA) {
/* No pixel transfer */
const GLint rowstride = texImage->RowStride;
MEMCPY(dest,
(const GLushort *) texImage->Data + row * rowstride,
width * sizeof(GLushort));
/* check for byte swapping */
if ((texImage->TexFormat->MesaFormat == MESA_FORMAT_YCBCR
&& type == GL_UNSIGNED_SHORT_8_8_REV_MESA) ||
(texImage->TexFormat->MesaFormat == MESA_FORMAT_YCBCR_REV
&& type == GL_UNSIGNED_SHORT_8_8_MESA)) {
if (!ctx->Pack.SwapBytes)
_mesa_swap2((GLushort *) dest, width);
}
else if (ctx->Pack.SwapBytes) {
_mesa_swap2((GLushort *) dest, width);
}
}
#if FEATURE_EXT_texture_sRGB
else if (is_srgb_teximage(texImage)) {
/* special case this since need to backconvert values */
/* convert row to RGBA format */
GLfloat rgba[MAX_WIDTH][4];
GLint col;
GLbitfield transferOps = 0x0;
for (col = 0; col < width; col++) {
(*texImage->FetchTexelf)(texImage, col, row, img, rgba[col]);
if (texImage->_BaseFormat == GL_LUMINANCE) {
rgba[col][RCOMP] = linear_to_nonlinear(rgba[col][RCOMP]);
rgba[col][GCOMP] = 0.0;
rgba[col][BCOMP] = 0.0;
}
else if (texImage->_BaseFormat == GL_LUMINANCE_ALPHA) {
rgba[col][RCOMP] = linear_to_nonlinear(rgba[col][RCOMP]);
rgba[col][GCOMP] = 0.0;
rgba[col][BCOMP] = 0.0;
}
else if (texImage->_BaseFormat == GL_RGB ||
texImage->_BaseFormat == GL_RGBA) {
rgba[col][RCOMP] = linear_to_nonlinear(rgba[col][RCOMP]);
rgba[col][GCOMP] = linear_to_nonlinear(rgba[col][GCOMP]);
rgba[col][BCOMP] = linear_to_nonlinear(rgba[col][BCOMP]);
}
}
_mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba,
format, type, dest,
&ctx->Pack, transferOps);
}
#endif /* FEATURE_EXT_texture_sRGB */
else {
/* general case: convert row to RGBA format */
GLfloat rgba[MAX_WIDTH][4];
GLint col;
GLbitfield transferOps = 0x0;
/* clamp does not apply to GetTexImage (final conversion)?
* Looks like we need clamp though when going from format
* containing negative values to unsigned format.
*/
if (format == GL_LUMINANCE || format == GL_LUMINANCE_ALPHA)
transferOps |= IMAGE_CLAMP_BIT;
else if (!type_with_negative_values(type) &&
(texImage->TexFormat->DataType == GL_FLOAT ||
texImage->TexFormat->DataType == GL_SIGNED_NORMALIZED))
transferOps |= IMAGE_CLAMP_BIT;
for (col = 0; col < width; col++) {
(*texImage->FetchTexelf)(texImage, col, row, img, rgba[col]);
if (texImage->_BaseFormat == GL_ALPHA) {
rgba[col][RCOMP] = 0.0;
rgba[col][GCOMP] = 0.0;
rgba[col][BCOMP] = 0.0;
}
else if (texImage->_BaseFormat == GL_LUMINANCE) {
rgba[col][GCOMP] = 0.0;
rgba[col][BCOMP] = 0.0;
rgba[col][ACOMP] = 1.0;
}
else if (texImage->_BaseFormat == GL_LUMINANCE_ALPHA) {
rgba[col][GCOMP] = 0.0;
rgba[col][BCOMP] = 0.0;
}
else if (texImage->_BaseFormat == GL_INTENSITY) {
rgba[col][GCOMP] = 0.0;
rgba[col][BCOMP] = 0.0;
rgba[col][ACOMP] = 1.0;
}
}
_mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba,
format, type, dest,
&ctx->Pack, transferOps);
} /* format */
} /* row */
} /* img */
}
if (ctx->Pack.BufferObj->Name) {
ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
ctx->Pack.BufferObj);
}
}
