/*
* Mesa 3-D graphics library
*
* Copyright (C) 1999-2008 Brian Paul 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, sublicense,
* 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 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 NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS 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.
*/
#include "glheader.h"
#include "imports.h"
#include "blend.h"
#include "bufferobj.h"
#include "context.h"
#include "enums.h"
#include "readpix.h"
#include "framebuffer.h"
#include "formats.h"
#include "format_unpack.h"
#include "image.h"
#include "mtypes.h"
#include "pack.h"
#include "pbo.h"
#include "state.h"
#include "glformats.h"
#include "fbobject.h"
#include "format_utils.h"
#include "pixeltransfer.h"
/**
* Return true if the conversion L=R+G+B is needed.
*/
GLboolean
_mesa_need_rgb_to_luminance_conversion(GLenum srcBaseFormat,
GLenum dstBaseFormat)
{
return (srcBaseFormat == GL_RG ||
srcBaseFormat == GL_RGB ||
srcBaseFormat == GL_RGBA) &&
(dstBaseFormat == GL_LUMINANCE ||
dstBaseFormat == GL_LUMINANCE_ALPHA);
}
/**
* Return true if the conversion L,I to RGB conversion is needed.
*/
GLboolean
_mesa_need_luminance_to_rgb_conversion(GLenum srcBaseFormat,
GLenum dstBaseFormat)
{
return (srcBaseFormat == GL_LUMINANCE ||
srcBaseFormat == GL_LUMINANCE_ALPHA ||
srcBaseFormat == GL_INTENSITY) &&
(dstBaseFormat == GL_GREEN ||
dstBaseFormat == GL_BLUE ||
dstBaseFormat == GL_RG ||
dstBaseFormat == GL_RGB ||
dstBaseFormat == GL_BGR ||
dstBaseFormat == GL_RGBA ||
dstBaseFormat == GL_BGRA);
}
/**
* Return transfer op flags for this ReadPixels operation.
*/
GLbitfield
_mesa_get_readpixels_transfer_ops(const struct gl_context *ctx,
mesa_format texFormat,
GLenum format, GLenum type,
GLboolean uses_blit)
{
GLbitfield transferOps = ctx->_ImageTransferState;
GLenum srcBaseFormat = _mesa_get_format_base_format(texFormat);
GLenum dstBaseFormat = _mesa_unpack_format_to_base_format(format);
if (format == GL_DEPTH_COMPONENT ||
format == GL_DEPTH_STENCIL ||
format == GL_STENCIL_INDEX) {
return 0;
}
/* Pixel transfer ops (scale, bias, table lookup) do not apply
* to integer formats.
*/
if (_mesa_is_enum_format_integer(format)) {
return 0;
}
if (uses_blit) {
/* For blit-based ReadPixels packing, the clamping is done automatically
* unless the type is float. */
if (_mesa_get_clamp_read_color(ctx, ctx->ReadBuffer) &&
(type == GL_FLOAT || type == GL_HALF_FLOAT)) {
transferOps |= IMAGE_CLAMP_BIT;
}
}
else {
/* For CPU-based ReadPixels packing, the clamping must always be done
* for non-float types, */
if (_mesa_get_clamp_read_color(ctx, ctx->ReadBuffer) ||
(type != GL_FLOAT && type != GL_HALF_FLOAT)) {
transferOps |= IMAGE_CLAMP_BIT;
}
}
/* If the format is unsigned normalized, we can ignore clamping
* because the values are already in the range [0,1] so it won't
* have any effect anyway.
*/
if (_mesa_get_format_datatype(texFormat) == GL_UNSIGNED_NORMALIZED &&
!_mesa_need_rgb_to_luminance_conversion(srcBaseFormat, dstBaseFormat)) {
transferOps &= ~IMAGE_CLAMP_BIT;
}
return transferOps;
}
/**
* Return true if memcpy cannot be used for ReadPixels.
*
* If uses_blit is true, the function returns true if a simple 3D engine blit
* cannot be used for ReadPixels packing.
*
* NOTE: This doesn't take swizzling and format conversions between
* the readbuffer and the pixel pack buffer into account.
*/
GLboolean
_mesa_readpixels_needs_slow_path(const struct gl_context *ctx, GLenum format,
GLenum type, GLboolean uses_blit)
{
struct gl_renderbuffer *rb =
_mesa_get_read_renderbuffer_for_format(ctx, format);
GLenum dstBaseFormat = _mesa_unpack_format_to_base_format(format);
assert(rb);
/* There are different rules depending on the base format. */
switch (format) {
case GL_DEPTH_STENCIL:
return !_mesa_has_depthstencil_combined(ctx->ReadBuffer) ||
ctx->Pixel.DepthScale != 1.0f || ctx->Pixel.DepthBias != 0.0f ||
ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
ctx->Pixel.MapStencilFlag;
case GL_DEPTH_COMPONENT:
return ctx->Pixel.DepthScale != 1.0f || ctx->Pixel.DepthBias != 0.0f;
case GL_STENCIL_INDEX:
return ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
ctx->Pixel.MapStencilFlag;
default:
/* Color formats. */
if (_mesa_need_rgb_to_luminance_conversion(rb->_BaseFormat,
dstBaseFormat)) {
return GL_TRUE;
}
/* And finally, see if there are any transfer ops. */
return _mesa_get_readpixels_transfer_ops(ctx, rb->Format, format, type,
uses_blit) != 0;
}
return GL_FALSE;
}
static GLboolean
readpixels_can_use_memcpy(const struct gl_context *ctx, GLenum format, GLenum type,
const struct gl_pixelstore_attrib *packing)
{
struct gl_renderbuffer *rb =
_mesa_get_read_renderbuffer_for_format(ctx, format);
assert(rb);
if (_mesa_readpixels_needs_slow_path(ctx, format, type, GL_FALSE)) {
return GL_FALSE;
}
/* The base internal format and the base Mesa format must match. */
if (rb->_BaseFormat != _mesa_get_format_base_format(rb->Format)) {
return GL_FALSE;
}
/* The Mesa format must match the input format and type. */
if (!_mesa_format_matches_format_and_type(rb->Format, format, type,
packing->SwapBytes, NULL)) {
return GL_FALSE;
}
return GL_TRUE;
}
static GLboolean
readpixels_memcpy(struct gl_context *ctx,
GLint x, GLint y,
GLsizei width, GLsizei height,
GLenum format, GLenum type,
GLvoid *pixels,
const struct gl_pixelstore_attrib *packing)
{
struct gl_renderbuffer *rb =
_mesa_get_read_renderbuffer_for_format(ctx, format);
GLubyte *dst, *map;
int dstStride, stride, j, texelBytes;
/* Fail if memcpy cannot be used. */
if (!readpixels_can_use_memcpy(ctx, format, type, packing)) {
return GL_FALSE;
}
dstStride = _mesa_image_row_stride(packing, width, format, type);
dst = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,
format, 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 GL_TRUE; /* don't bother trying the slow path */
}
texelBytes = _mesa_get_format_bytes(rb->Format);
/* memcpy*/
for (j = 0; j < height; j++) {
memcpy(dst, map, width * texelBytes);
dst += dstStride;
map += stride;
}
ctx->Driver.UnmapRenderbuffer(ctx, rb);
return GL_TRUE;
}
/**
* Optimized path for conversion of depth values to GL_DEPTH_COMPONENT,
* GL_UNSIGNED_INT.
*/
static GLboolean
read_uint_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;
GLubyte *map, *dst;
int stride, dstStride, j;
if (ctx->Pixel.DepthScale != 1.0F || ctx->Pixel.DepthBias != 0.0F)
return GL_FALSE;
if (packing->SwapBytes)
return GL_FALSE;
if (_mesa_get_format_datatype(rb->Format) != GL_UNSIGNED_NORMALIZED)
return GL_FALSE;
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 GL_TRUE; /* don't bother trying the slow path */
}
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);
for (j = 0; j < height; j++) {
_mesa_unpack_uint_z_row(rb->Format, width, map, (GLuint *)dst);
map += stride;
dst += dstStride;
}
ctx->Driver.UnmapRenderbuffer(ctx, rb);
return GL_TRUE;
}
/**
* 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);
}
/**
* Read pixels for format=GL_STENCIL_INDEX.
*/
static void
read_stencil_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_STENCIL].Renderbuffer;
GLint j;
GLubyte *map, *stencil;
GLint stride;
if (!rb)
return;
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;
}
stencil = malloc(width * sizeof(GLubyte));
if (stencil) {
/* process image row by row */
for (j = 0; j < height; j++) {
GLvoid *dest;
_mesa_unpack_ubyte_stencil_row(rb->Format, width, map, stencil);
dest = _mesa_image_address2d(packing, pixels, width, height,
GL_STENCIL_INDEX, type, j, 0);
_mesa_pack_stencil_span(ctx, width, type, dest, stencil, packing);
map += stride;
}
}
else {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
}
free(stencil);
ctx->Driver.UnmapRenderbuffer(ctx, rb);
}
/*
* Read R, G, B, A, RGB, L, or LA pixels.
*/
static void
read_rgba_pixels( struct gl_context *ctx,
GLint x, GLint y,
GLsizei width, GLsizei height,
GLenum format, GLenum type, GLvoid *pixels,
const struct gl_pixelstore_attrib *packing )
{
GLbitfield transferOps;
bool dst_is_integer, convert_rgb_to_lum, needs_rebase;
int dst_stride, src_stride, rb_stride;
uint32_t dst_format, src_format;
GLubyte *dst, *map;
mesa_format rb_format;
bool needs_rgba;
void *rgba, *src;
bool src_is_uint = false;
uint8_t rebase_swizzle[4];
struct gl_framebuffer *fb = ctx->ReadBuffer;
struct gl_renderbuffer *rb = fb->_ColorReadBuffer;
GLenum dstBaseFormat = _mesa_unpack_format_to_base_format(format);
if (!rb)
return;
transferOps = _mesa_get_readpixels_transfer_ops(ctx, rb->Format, format,
type, GL_FALSE);
/* Describe the dst format */
dst_is_integer = _mesa_is_enum_format_integer(format);
dst_stride = _mesa_image_row_stride(packing, width, format, type);
dst_format = _mesa_format_from_format_and_type(format, type);
convert_rgb_to_lum =
_mesa_need_rgb_to_luminance_conversion(rb->_BaseFormat, dstBaseFormat);
dst = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,
format, type, 0, 0);
/* Map the source render buffer */
ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, GL_MAP_READ_BIT,
&map, &rb_stride);
if (!map) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
return;
}
rb_format = _mesa_get_srgb_format_linear(rb->Format);
/*
* Depending on the base formats involved in the conversion we might need to
* rebase some values, so for these formats we compute a rebase swizzle.
*/
if (rb->_BaseFormat == GL_LUMINANCE || rb->_BaseFormat == GL_INTENSITY) {
needs_rebase = true;
rebase_swizzle[0] = MESA_FORMAT_SWIZZLE_X;
rebase_swizzle[1] = MESA_FORMAT_SWIZZLE_ZERO;
rebase_swizzle[2] = MESA_FORMAT_SWIZZLE_ZERO;
rebase_swizzle[3] = MESA_FORMAT_SWIZZLE_ONE;
} else if (rb->_BaseFormat == GL_LUMINANCE_ALPHA) {
needs_rebase = true;
rebase_swizzle[0] = MESA_FORMAT_SWIZZLE_X;
rebase_swizzle[1] = MESA_FORMAT_SWIZZLE_ZERO;
rebase_swizzle[2] = MESA_FORMAT_SWIZZLE_ZERO;
rebase_swizzle[3] = MESA_FORMAT_SWIZZLE_W;
} else if (_mesa_get_format_base_format(rb_format) != rb->_BaseFormat) {
needs_rebase =
_mesa_compute_rgba2base2rgba_component_mapping(rb->_BaseFormat,
rebase_swizzle);
} else {
needs_rebase = false;
}
/* Since _mesa_format_convert does not handle transferOps we need to handle
* them before we call the function. This requires to convert to RGBA float
* first so we can call _mesa_apply_rgba_transfer_ops. If the dst format is
* integer transferOps do not apply.
*
* Converting to luminance also requires converting to RGBA first, so we can
* then compute luminance values as L=R+G+B. Notice that this is different
* from GetTexImage, where we compute L=R.
*/
assert(!transferOps || (transferOps && !dst_is_integer));
needs_rgba = transferOps || convert_rgb_to_lum;
rgba = NULL;
if (needs_rgba) {
uint32_t rgba_format;
int rgba_stride;
bool need_convert;
/* Convert to RGBA float or int/uint depending on the type of the src */
if (dst_is_integer) {
src_is_uint = _mesa_is_format_unsigned(rb_format);
if (src_is_uint) {
rgba_format = RGBA32_UINT;
rgba_stride = width * 4 * sizeof(GLuint);
} else {
rgba_format = RGBA32_INT;
rgba_stride = width * 4 * sizeof(GLint);
}
} else {
rgba_format = RGBA32_FLOAT;
rgba_stride = width * 4 * sizeof(GLfloat);
}
/* If we are lucky and the dst format matches the RGBA format we need to
* convert to, then we can convert directly into the dst buffer and avoid
* the final conversion/copy from the rgba buffer to the dst buffer.
*/
if (dst_format == rgba_format &&
dst_stride == rgba_stride) {
need_convert = false;
rgba = dst;
} else {
need_convert = true;
rgba = malloc(height * rgba_stride);
if (!rgba) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
goto done_unmap;
}
}
/* Convert to RGBA now */
_mesa_format_convert(rgba, rgba_format, rgba_stride,
map, rb_format, rb_stride,
width, height,
needs_rebase ? rebase_swizzle : NULL);
/* Handle transfer ops if necessary */
if (transferOps)
_mesa_apply_rgba_transfer_ops(ctx, transferOps, width * height, rgba);
/* If we had to rebase, we have already taken care of that */
needs_rebase = false;
/* If we were lucky and our RGBA conversion matches the dst format, then
* we are done.
*/
if (!need_convert)
goto done_swap;
/* Otherwise, we need to convert from RGBA to dst next */
src = rgba;
src_format = rgba_format;
src_stride = rgba_stride;
} else {
/* No RGBA conversion needed, convert directly to dst */
src = map;
src_format = rb_format;
src_stride = rb_stride;
}
/* Do the conversion.
*
* If the dst format is Luminance, we need to do the conversion by computing
* L=R+G+B values.
*/
if (!convert_rgb_to_lum) {
_mesa_format_convert(dst, dst_format, dst_stride,
src, src_format, src_stride,
width, height,
needs_rebase ? rebase_swizzle : NULL);
} else if (!dst_is_integer) {
/* Compute float Luminance values from RGBA float */
int luminance_stride, luminance_bytes;
void *luminance;
uint32_t luminance_format;
luminance_stride = width * sizeof(GLfloat);
if (format == GL_LUMINANCE_ALPHA)
luminance_stride *= 2;
luminance_bytes = height * luminance_stride;
luminance = malloc(luminance_bytes);
if (!luminance) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
free(rgba);
goto done_unmap;
}
_mesa_pack_luminance_from_rgba_float(width * height, src,
luminance, format, transferOps);
/* Convert from Luminance float to dst (this will hadle type conversion
* from float to the type of dst if necessary)
*/
luminance_format = _mesa_format_from_format_and_type(format, GL_FLOAT);
_mesa_format_convert(dst, dst_format, dst_stride,
luminance, luminance_format, luminance_stride,
width, height, NULL);
free(luminance);
} else {
_mesa_pack_luminance_from_rgba_integer(width * height, src, !src_is_uint,
dst, format, type);
}
free(rgba);
done_swap:
/* Handle byte swapping if required */
if (packing->SwapBytes) {
_mesa_swap_bytes_2d_image(format, type, packing,
width, height, dst, dst);
}
done_unmap:
ctx->Driver.UnmapRenderbuffer(ctx, rb);
}
/**
* For a packed depth/stencil buffer being read as depth/stencil, just memcpy the
* data (possibly swapping 8/24 vs 24/8 as we go).
*/
static GLboolean
fast_read_depth_stencil_pixels(struct gl_context *ctx,
GLint x, GLint y,
GLsizei width, GLsizei height,
GLubyte *dst, int dstStride)
{
struct gl_framebuffer *fb = ctx->ReadBuffer;
struct gl_renderbuffer *rb = fb->Attachment[BUFFER_DEPTH].Renderbuffer;
struct gl_renderbuffer *stencilRb = fb->Attachment[BUFFER_STENCIL].Renderbuffer;
GLubyte *map;
int stride, i;
if (rb != stencilRb)
return GL_FALSE;
if (rb->Format != MESA_FORMAT_S8_UINT_Z24_UNORM &&
rb->Format != MESA_FORMAT_Z24_UNORM_S8_UINT)
return GL_FALSE;
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 GL_TRUE; /* don't bother trying the slow path */
}
for (i = 0; i < height; i++) {
_mesa_unpack_uint_24_8_depth_stencil_row(rb->Format, width,
map, (GLuint *)dst);
map += stride;
dst += dstStride;
}
ctx->Driver.UnmapRenderbuffer(ctx, rb);
return GL_TRUE;
}
/**
* For non-float-depth and stencil buffers being read as 24/8 depth/stencil,
* copy the integer data directly instead of converting depth to float and
* re-packing.
*/
static GLboolean
fast_read_depth_stencil_pixels_separate(struct gl_context *ctx,
GLint x, GLint y,
GLsizei width, GLsizei height,
uint32_t *dst, int dstStride)
{
struct gl_framebuffer *fb = ctx->ReadBuffer;
struct gl_renderbuffer *depthRb = fb->Attachment[BUFFER_DEPTH].Renderbuffer;
struct gl_renderbuffer *stencilRb = fb->Attachment[BUFFER_STENCIL].Renderbuffer;
GLubyte *depthMap, *stencilMap, *stencilVals;
int depthStride, stencilStride, i, j;
if (_mesa_get_format_datatype(depthRb->Format) != GL_UNSIGNED_NORMALIZED)
return GL_FALSE;
ctx->Driver.MapRenderbuffer(ctx, depthRb, x, y, width, height,
GL_MAP_READ_BIT, &depthMap, &depthStride);
if (!depthMap) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
return GL_TRUE; /* don't bother trying the slow path */
}
ctx->Driver.MapRenderbuffer(ctx, stencilRb, x, y, width, height,
GL_MAP_READ_BIT, &stencilMap, &stencilStride);
if (!stencilMap) {
ctx->Driver.UnmapRenderbuffer(ctx, depthRb);
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
return GL_TRUE; /* don't bother trying the slow path */
}
stencilVals = malloc(width * sizeof(GLubyte));
if (stencilVals) {
for (j = 0; j < height; j++) {
_mesa_unpack_uint_z_row(depthRb->Format, width, depthMap, dst);
_mesa_unpack_ubyte_stencil_row(stencilRb->Format, width,
stencilMap, stencilVals);
for (i = 0; i < width; i++) {
dst[i] = (dst[i] & 0xffffff00) | stencilVals[i];
}
depthMap += depthStride;
stencilMap += stencilStride;
dst += dstStride / 4;
}
}
else {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
}
free(stencilVals);
ctx->Driver.UnmapRenderbuffer(ctx, depthRb);
ctx->Driver.UnmapRenderbuffer(ctx, stencilRb);
return GL_TRUE;
}
static void
slow_read_depth_stencil_pixels_separate(struct gl_context *ctx,
GLint x, GLint y,
GLsizei width, GLsizei height,
GLenum type,
const struct gl_pixelstore_attrib *packing,
GLubyte *dst, int dstStride)
{
struct gl_framebuffer *fb = ctx->ReadBuffer;
struct gl_renderbuffer *depthRb = fb->Attachment[BUFFER_DEPTH].Renderbuffer;
struct gl_renderbuffer *stencilRb = fb->Attachment[BUFFER_STENCIL].Renderbuffer;
GLubyte *depthMap, *stencilMap;
int depthStride, stencilStride, j;
GLubyte *stencilVals;
GLfloat *depthVals;
/* The depth and stencil buffers might be separate, or a single buffer.
* If one buffer, only map it once.
*/
ctx->Driver.MapRenderbuffer(ctx, depthRb, x, y, width, height,
GL_MAP_READ_BIT, &depthMap, &depthStride);
if (!depthMap) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
return;
}
if (stencilRb != depthRb) {
ctx->Driver.MapRenderbuffer(ctx, stencilRb, x, y, width, height,
GL_MAP_READ_BIT, &stencilMap,
&stencilStride);
if (!stencilMap) {
ctx->Driver.UnmapRenderbuffer(ctx, depthRb);
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
return;
}
}
else {
stencilMap = depthMap;
stencilStride = depthStride;
}
stencilVals = malloc(width * sizeof(GLubyte));
depthVals = malloc(width * sizeof(GLfloat));
if (stencilVals && depthVals) {
for (j = 0; j < height; j++) {
_mesa_unpack_float_z_row(depthRb->Format, width, depthMap, depthVals);
_mesa_unpack_ubyte_stencil_row(stencilRb->Format, width,
stencilMap, stencilVals);
_mesa_pack_depth_stencil_span(ctx, width, type, (GLuint *)dst,
depthVals, stencilVals, packing);
depthMap += depthStride;
stencilMap += stencilStride;
dst += dstStride;
}
}
else {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
}
free(stencilVals);
free(depthVals);
ctx->Driver.UnmapRenderbuffer(ctx, depthRb);
if (stencilRb != depthRb) {
ctx->Driver.UnmapRenderbuffer(ctx, stencilRb);
}
}
/**
* Read combined depth/stencil values.
* We'll have already done error checking to be sure the expected
* depth and stencil buffers really exist.
*/
static void
read_depth_stencil_pixels(struct gl_context *ctx,
GLint x, GLint y,
GLsizei width, GLsizei height,
GLenum type, GLvoid *pixels,
const struct gl_pixelstore_attrib *packing )
{
const GLboolean scaleOrBias
= ctx->Pixel.DepthScale != 1.0F || ctx->Pixel.DepthBias != 0.0F;
const GLboolean stencilTransfer = ctx->Pixel.IndexShift
|| ctx->Pixel.IndexOffset || ctx->Pixel.MapStencilFlag;
GLubyte *dst;
int dstStride;
dst = (GLubyte *) _mesa_image_address2d(packing, pixels,
width, height,
GL_DEPTH_STENCIL_EXT,
type, 0, 0);
dstStride = _mesa_image_row_stride(packing, width,
GL_DEPTH_STENCIL_EXT, type);
/* Fast 24/8 reads. */
if (type == GL_UNSIGNED_INT_24_8 &&
!scaleOrBias && !stencilTransfer && !packing->SwapBytes) {
if (fast_read_depth_stencil_pixels(ctx, x, y, width, height,
dst, dstStride))
return;
if (fast_read_depth_stencil_pixels_separate(ctx, x, y, width, height,
(uint32_t *)dst, dstStride))
return;
}
slow_read_depth_stencil_pixels_separate(ctx, x, y, width, height,
type, packing,
dst, dstStride);
}
/**
* Software fallback routine for ctx->Driver.ReadPixels().
* By time we get here, all error checking will have been done.
*/
void
_mesa_readpixels(struct gl_context *ctx,
GLint x, GLint y, GLsizei width, GLsizei height,
GLenum format, GLenum type,
const struct gl_pixelstore_attrib *packing,
GLvoid *pixels)
{
if (ctx->NewState)
_mesa_update_state(ctx);
pixels = _mesa_map_pbo_dest(ctx, packing, pixels);
if (pixels) {
/* Try memcpy first. */
if (readpixels_memcpy(ctx, x, y, width, height, format, type,
pixels, packing)) {
_mesa_unmap_pbo_dest(ctx, packing);
return;
}
/* Otherwise take the slow path. */
switch (format) {
case GL_STENCIL_INDEX:
read_stencil_pixels(ctx, x, y, width, height, type, pixels,
packing);
break;
case GL_DEPTH_COMPONENT:
read_depth_pixels(ctx, x, y, width, height, type, pixels,
packing);
break;
case GL_DEPTH_STENCIL_EXT:
read_depth_stencil_pixels(ctx, x, y, width, height, type, pixels,
packing);
break;
default:
/* all other formats should be color formats */
read_rgba_pixels(ctx, x, y, width, height, format, type, pixels,
packing);
}
_mesa_unmap_pbo_dest(ctx, packing);
}
}
static GLenum
read_pixels_es3_error_check(GLenum format, GLenum type,
const struct gl_renderbuffer *rb)
{
const GLenum internalFormat = rb->InternalFormat;
const GLenum data_type = _mesa_get_format_datatype(rb->Format);
GLboolean is_unsigned_int = GL_FALSE;
GLboolean is_signed_int = GL_FALSE;
GLboolean is_float_depth = (internalFormat == GL_DEPTH_COMPONENT32F) ||
(internalFormat == GL_DEPTH32F_STENCIL8);
is_unsigned_int = _mesa_is_enum_format_unsigned_int(internalFormat);
if (!is_unsigned_int) {
is_signed_int = _mesa_is_enum_format_signed_int(internalFormat);
}
switch (format) {
case GL_RGBA:
if (type == GL_FLOAT && data_type == GL_FLOAT)
return GL_NO_ERROR; /* EXT_color_buffer_float */
if (type == GL_UNSIGNED_BYTE && data_type == GL_UNSIGNED_NORMALIZED)
return GL_NO_ERROR;
if (internalFormat == GL_RGB10_A2 &&
type == GL_UNSIGNED_INT_2_10_10_10_REV)
return GL_NO_ERROR;
if (internalFormat == GL_RGB10_A2UI && type == GL_UNSIGNED_BYTE)
return GL_NO_ERROR;
break;
case GL_BGRA:
/* GL_EXT_read_format_bgra */
if (type == GL_UNSIGNED_BYTE ||
type == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
type == GL_UNSIGNED_SHORT_1_5_5_5_REV)
return GL_NO_ERROR;
break;
case GL_RGBA_INTEGER:
if ((is_signed_int && type == GL_INT) ||
(is_unsigned_int && type == GL_UNSIGNED_INT))
return GL_NO_ERROR;
break;
case GL_DEPTH_STENCIL:
switch (type) {
case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
if (is_float_depth)
return GL_NO_ERROR;
break;
case GL_UNSIGNED_INT_24_8:
if (!is_float_depth)
return GL_NO_ERROR;
break;
default:
return GL_INVALID_ENUM;
}
break;
case GL_DEPTH_COMPONENT:
switch (type) {
case GL_FLOAT:
if (is_float_depth)
return GL_NO_ERROR;
break;
case GL_UNSIGNED_SHORT:
case GL_UNSIGNED_INT:
case GL_UNSIGNED_INT_24_8:
if (!is_float_depth)
return GL_NO_ERROR;
break;
default:
return GL_INVALID_ENUM;
}
break;
case GL_STENCIL_INDEX:
switch (type) {
case GL_UNSIGNED_BYTE:
return GL_NO_ERROR;
default:
return GL_INVALID_ENUM;
}
break;
}
return GL_INVALID_OPERATION;
}
void GLAPIENTRY
_mesa_ReadnPixelsARB( GLint x, GLint y, GLsizei width, GLsizei height,
GLenum format, GLenum type, GLsizei bufSize,
GLvoid *pixels )
{
GLenum err = GL_NO_ERROR;
struct gl_renderbuffer *rb;
struct gl_pixelstore_attrib clippedPacking;
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
FLUSH_CURRENT(ctx, 0);
if (MESA_VERBOSE & VERBOSE_API)
_mesa_debug(ctx, "glReadPixels(%d, %d, %s, %s, %p)\n",
width, height,
_mesa_enum_to_string(format),
_mesa_enum_to_string(type),
pixels);
if (width < 0 || height < 0) {
_mesa_error( ctx, GL_INVALID_VALUE,
"glReadPixels(width=%d height=%d)", width, height );
return;
}
if (ctx->NewState)
_mesa_update_state(ctx);
if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
_mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
"glReadPixels(incomplete framebuffer)" );
return;
}
rb = _mesa_get_read_renderbuffer_for_format(ctx, format);
if (rb == NULL) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glReadPixels(read buffer)");
return;
}
/* OpenGL ES 1.x and OpenGL ES 2.0 impose additional restrictions on the
* combinations of format and type that can be used.
*
* Technically, only two combinations are actually allowed:
* GL_RGBA/GL_UNSIGNED_BYTE, and some implementation-specific internal
* preferred combination. This code doesn't know what that preferred
* combination is, and Mesa can handle anything valid. Just work instead.
*/
if (_mesa_is_gles(ctx)) {
if (ctx->API == API_OPENGLES2 &&
_mesa_is_color_format(format) &&
_mesa_get_color_read_format(ctx) == format &&
_mesa_get_color_read_type(ctx) == type) {
err = GL_NO_ERROR;
} else if (ctx->Version < 30) {
err = _mesa_es_error_check_format_and_type(ctx, format, type, 2);
if (err == GL_NO_ERROR) {
if (type == GL_FLOAT || type == GL_HALF_FLOAT_OES) {
err = GL_INVALID_OPERATION;
}
}
} else {
err = read_pixels_es3_error_check(format, type, rb);
}
if (err != GL_NO_ERROR) {
_mesa_error(ctx, err, "glReadPixels(invalid format %s and/or type %s)",
_mesa_enum_to_string(format),
_mesa_enum_to_string(type));
return;
}
}
err = _mesa_error_check_format_and_type(ctx, format, type);
if (err != GL_NO_ERROR) {
_mesa_error(ctx, err, "glReadPixels(invalid format %s and/or type %s)",
_mesa_enum_to_string(format),
_mesa_enum_to_string(type));
return;
}
if (_mesa_is_user_fbo(ctx->ReadBuffer) &&
ctx->ReadBuffer->Visual.samples > 0) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glReadPixels(multisample FBO)");
return;
}
if (!_mesa_source_buffer_exists(ctx, format)) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glReadPixels(no readbuffer)");
return;
}
/* Check that the destination format and source buffer are both
* integer-valued or both non-integer-valued.
*/
if (ctx->Extensions.EXT_texture_integer && _mesa_is_color_format(format)) {
const struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer;
const GLboolean srcInteger = _mesa_is_format_integer_color(rb->Format);
const GLboolean dstInteger = _mesa_is_enum_format_integer(format);
if (dstInteger != srcInteger) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glReadPixels(integer / non-integer format mismatch");
return;
}
}
/* Do all needed clipping here, so that we can forget about it later */
clippedPacking = ctx->Pack;
if (!_mesa_clip_readpixels(ctx, &x, &y, &width, &height, &clippedPacking))
return; /* nothing to do */
if (!_mesa_validate_pbo_access(2, &ctx->Pack, width, height, 1,
format, type, bufSize, pixels)) {
if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glReadPixels(out of bounds PBO access)");
} else {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glReadnPixelsARB(out of bounds access:"
" bufSize (%d) is too small)", bufSize);
}
return;
}
if (_mesa_is_bufferobj(ctx->Pack.BufferObj) &&
_mesa_check_disallowed_mapping(ctx->Pack.BufferObj)) {
/* buffer is mapped - that's an error */
_mesa_error(ctx, GL_INVALID_OPERATION, "glReadPixels(PBO is mapped)");
return;
}
ctx->Driver.ReadPixels(ctx, x, y, width, height,
format, type, &clippedPacking, pixels);
}
void GLAPIENTRY
_mesa_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
GLenum format, GLenum type, GLvoid *pixels )
{
_mesa_ReadnPixelsARB(x, y, width, height, format, type, INT_MAX, pixels);
}