/*
* Mesa 3-D graphics library
- * Version: 7.7
*
* Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
* Copyright (c) 2009 VMware, Inc.
* 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
- * BRIAN PAUL 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.
+ * 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 "format_unpack.h"
#include "glformats.h"
#include "image.h"
-#include "mfeatures.h"
#include "mtypes.h"
#include "pack.h"
#include "pbo.h"
GLbitfield transferOps)
{
/* don't want to apply sRGB -> RGB conversion here so override the format */
- const gl_format texFormat =
+ const mesa_format texFormat =
_mesa_get_srgb_format_linear(texImage->TexFormat);
const GLenum baseFormat = _mesa_get_format_base_format(texFormat);
const GLenum destBaseFormat = _mesa_base_tex_format(ctx, format);
const GLuint width = texImage->Width;
const GLuint height = texImage->Height;
const GLuint depth = texImage->Depth;
- GLfloat *tempImage, *srcRow;
- GLuint row;
+ GLfloat *tempImage, *tempSlice, *srcRow;
+ GLuint row, slice;
/* Decompress into temp float buffer, then pack into user buffer */
tempImage = malloc(width * height * depth
return;
}
- /* Decompress the texture image - results in 'tempImage' */
- {
+ /* Decompress the texture image slices - results in 'tempImage' */
+ for (slice = 0; slice < depth; slice++) {
GLubyte *srcMap;
GLint srcRowStride;
- ctx->Driver.MapTextureImage(ctx, texImage, 0,
+ tempSlice = tempImage + slice * 4 * width * height;
+
+ ctx->Driver.MapTextureImage(ctx, texImage, slice,
0, 0, width, height,
GL_MAP_READ_BIT,
&srcMap, &srcRowStride);
if (srcMap) {
_mesa_decompress_image(texFormat, width, height,
- srcMap, srcRowStride, tempImage);
+ srcMap, srcRowStride, tempSlice);
- ctx->Driver.UnmapTextureImage(ctx, texImage, 0);
+ ctx->Driver.UnmapTextureImage(ctx, texImage, slice);
}
else {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage");
rebaseFormat);
}
- srcRow = tempImage;
- for (row = 0; row < height; row++) {
- void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,
- width, height, format, type,
- 0, row, 0);
-
- _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) srcRow,
- format, type, dest, &ctx->Pack, transferOps);
- srcRow += width * 4;
+ tempSlice = tempImage;
+ for (slice = 0; slice < depth; slice++) {
+ srcRow = tempSlice;
+ for (row = 0; row < height; row++) {
+ void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,
+ width, height, format, type,
+ slice, row, 0);
+
+ _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) srcRow,
+ format, type, dest, &ctx->Pack, transferOps);
+ srcRow += 4 * width;
+ }
+ tempSlice += 4 * width * height;
}
free(tempImage);
* Return a base GL format given the user-requested format
* for glGetTexImage().
*/
-static GLenum
+GLenum
_mesa_base_pack_format(GLenum format)
{
switch (format) {
GLbitfield transferOps)
{
/* don't want to apply sRGB -> RGB conversion here so override the format */
- const gl_format texFormat =
+ const mesa_format texFormat =
_mesa_get_srgb_format_linear(texImage->TexFormat);
const GLuint width = texImage->Width;
GLenum destBaseFormat = _mesa_base_pack_format(format);
GLuint (*rgba_uint)[4];
GLboolean tex_is_integer = _mesa_is_format_integer_color(texImage->TexFormat);
GLboolean tex_is_uint = _mesa_is_format_unsigned(texImage->TexFormat);
+ GLenum texBaseFormat = _mesa_get_format_base_format(texImage->TexFormat);
/* Allocate buffer for one row of texels */
rgba = malloc(4 * width * sizeof(GLfloat));
*/
rebaseFormat = GL_LUMINANCE_ALPHA; /* this covers GL_LUMINANCE too */
}
+ else if (texImage->_BaseFormat != texBaseFormat) {
+ /* The internal format and the real format differ, so we can't rely
+ * on the unpack functions setting the correct constant values.
+ * (e.g. reading back GL_RGB8 which is actually RGBA won't set alpha=1)
+ */
+ switch (texImage->_BaseFormat) {
+ case GL_RED:
+ if ((texBaseFormat == GL_RGBA ||
+ texBaseFormat == GL_RGB ||
+ texBaseFormat == GL_RG) &&
+ (destBaseFormat == GL_RGBA ||
+ destBaseFormat == GL_RGB ||
+ destBaseFormat == GL_RG ||
+ destBaseFormat == GL_GREEN)) {
+ rebaseFormat = texImage->_BaseFormat;
+ break;
+ }
+ /* fall through */
+ case GL_RG:
+ if ((texBaseFormat == GL_RGBA ||
+ texBaseFormat == GL_RGB) &&
+ (destBaseFormat == GL_RGBA ||
+ destBaseFormat == GL_RGB ||
+ destBaseFormat == GL_BLUE)) {
+ rebaseFormat = texImage->_BaseFormat;
+ break;
+ }
+ /* fall through */
+ case GL_RGB:
+ if (texBaseFormat == GL_RGBA &&
+ (destBaseFormat == GL_RGBA ||
+ destBaseFormat == GL_ALPHA ||
+ destBaseFormat == GL_LUMINANCE_ALPHA)) {
+ rebaseFormat = texImage->_BaseFormat;
+ }
+ break;
+
+ case GL_ALPHA:
+ if (destBaseFormat != GL_ALPHA) {
+ rebaseFormat = texImage->_BaseFormat;
+ }
+ break;
+ }
+ }
for (img = 0; img < depth; img++) {
GLubyte *srcMap;
if (type_needs_clamping(type)) {
/* the returned image type can't have negative values */
if (dataType == GL_FLOAT ||
+ dataType == GL_HALF_FLOAT ||
dataType == GL_SIGNED_NORMALIZED ||
format == GL_LUMINANCE ||
format == GL_LUMINANCE_ALPHA) {
{
const GLenum target = texImage->TexObject->Target;
GLboolean memCopy = GL_FALSE;
+ GLenum texBaseFormat = _mesa_get_format_base_format(texImage->TexFormat);
/*
* Check if we can use memcpy to copy from the hardware texture
* format to the user's format/type.
* Note that GL's pixel transfer ops don't apply to glGetTexImage()
*/
- if (target == GL_TEXTURE_1D ||
- target == GL_TEXTURE_2D ||
- target == GL_TEXTURE_RECTANGLE ||
- _mesa_is_cube_face(target)) {
+ if ((target == GL_TEXTURE_1D ||
+ target == GL_TEXTURE_2D ||
+ target == GL_TEXTURE_RECTANGLE ||
+ _mesa_is_cube_face(target)) &&
+ texBaseFormat == texImage->_BaseFormat) {
memCopy = _mesa_format_matches_format_and_type(texImage->TexFormat,
format, type,
ctx->Pack.SwapBytes);
GLenum format, GLenum type, GLvoid *pixels,
struct gl_texture_image *texImage)
{
- GLuint dimensions;
-
- switch (texImage->TexObject->Target) {
- case GL_TEXTURE_1D:
- dimensions = 1;
- break;
- case GL_TEXTURE_3D:
- dimensions = 3;
- break;
- default:
- dimensions = 2;
- }
+ const GLuint dimensions =
+ _mesa_get_texture_dimensions(texImage->TexObject->Target);
/* map dest buffer, if PBO */
if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
return ctx->Extensions.NV_texture_rectangle;
case GL_TEXTURE_1D_ARRAY_EXT:
case GL_TEXTURE_2D_ARRAY_EXT:
- return (ctx->Extensions.MESA_texture_array ||
- ctx->Extensions.EXT_texture_array);
+ return ctx->Extensions.EXT_texture_array;
case GL_TEXTURE_CUBE_MAP_ARRAY:
return ctx->Extensions.ARB_texture_cube_map_array;
default:
if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
/* PBO should not be mapped */
- if (_mesa_bufferobj_mapped(ctx->Pack.BufferObj)) {
+ if (_mesa_check_disallowed_mapping(ctx->Pack.BufferObj)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glGetTexImage(PBO is mapped)");
return GL_TRUE;
}
/* make sure PBO is not mapped */
- if (_mesa_bufferobj_mapped(ctx->Pack.BufferObj)) {
+ if (_mesa_check_disallowed_mapping(ctx->Pack.BufferObj)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glGetCompressedTexImage(PBO is mapped)");
return GL_TRUE;