Google Git
Sign in
android / platform / external / mesa3d / 537dbf6d8f0e9630b41282f7907bbd399590a640 / . / src / mesa / main / pack.c
blob: 4c99199d9d11536f5a38f73e92cded42ba89b15e [file] [log] [blame]
/*
* Mesa 3-D graphics library
*
* Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
* Copyright (C) 2009-2010 VMware, Inc. 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
* THEA AUTHORS 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.
*/
/**
* \file pack.c
* Image and pixel span packing and unpacking.
*/
/*
* XXX: MSVC takes forever to compile this module for x86_64 unless we disable
* this global optimization.
*
* See also:
* - http://msdn.microsoft.com/en-us/library/1yk3ydd7.aspx
* - http://msdn.microsoft.com/en-us/library/chh3fb0k.aspx
*/
#if defined(_MSC_VER) && defined(_M_X64)
# pragma optimize( "g", off )
#endif
#include "glheader.h"
#include "colormac.h"
#include "enums.h"
#include "image.h"
#include "imports.h"
#include "macros.h"
#include "mtypes.h"
#include "pack.h"
#include "pixeltransfer.h"
#include "imports.h"
#include "glformats.h"
#include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
#include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
/**
* Flip the 8 bits in each byte of the given array.
*
* \param p array.
* \param n number of bytes.
*
* \todo try this trick to flip bytes someday:
* \code
* v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
* v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
* v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
* \endcode
*/
static void
flip_bytes( GLubyte *p, GLuint n )
{
GLuint i, a, b;
for (i = 0; i < n; i++) {
b = (GLuint) p[i]; /* words are often faster than bytes */
a = ((b & 0x01) << 7) |
((b & 0x02) << 5) |
((b & 0x04) << 3) |
((b & 0x08) << 1) |
((b & 0x10) >> 1) |
((b & 0x20) >> 3) |
((b & 0x40) >> 5) |
((b & 0x80) >> 7);
p[i] = (GLubyte) a;
}
}
/*
* Unpack a 32x32 pixel polygon stipple from user memory using the
* current pixel unpack settings.
*/
void
_mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],
const struct gl_pixelstore_attrib *unpacking )
{
GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap(32, 32, pattern, unpacking);
if (ptrn) {
/* Convert pattern from GLubytes to GLuints and handle big/little
* endian differences
*/
GLubyte *p = ptrn;
GLint i;
for (i = 0; i < 32; i++) {
dest[i] = (p[0] << 24)
| (p[1] << 16)
| (p[2] << 8)
| (p[3] );
p += 4;
}
free(ptrn);
}
}
/*
* Pack polygon stipple into user memory given current pixel packing
* settings.
*/
void
_mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,
const struct gl_pixelstore_attrib *packing )
{
/* Convert pattern from GLuints to GLubytes to handle big/little
* endian differences.
*/
GLubyte ptrn[32*4];
GLint i;
for (i = 0; i < 32; i++) {
ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);
ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);
ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);
ptrn[i * 4 + 3] = (GLubyte) ((pattern[i] ) & 0xff);
}
_mesa_pack_bitmap(32, 32, ptrn, dest, packing);
}
/*
* Unpack bitmap data. Resulting data will be in most-significant-bit-first
* order with row alignment = 1 byte.
*/
GLvoid *
_mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
const struct gl_pixelstore_attrib *packing )
{
GLint bytes, row, width_in_bytes;
GLubyte *buffer, *dst;
if (!pixels)
return NULL;
/* Alloc dest storage */
bytes = ((width + 7) / 8 * height);
buffer = (GLubyte *) malloc( bytes );
if (!buffer)
return NULL;
width_in_bytes = CEILING( width, 8 );
dst = buffer;
for (row = 0; row < height; row++) {
const GLubyte *src = (const GLubyte *)
_mesa_image_address2d(packing, pixels, width, height,
GL_COLOR_INDEX, GL_BITMAP, row, 0);
if (!src) {
free(buffer);
return NULL;
}
if ((packing->SkipPixels & 7) == 0) {
memcpy( dst, src, width_in_bytes );
if (packing->LsbFirst) {
flip_bytes( dst, width_in_bytes );
}
}
else {
/* handling SkipPixels is a bit tricky (no pun intended!) */
GLint i;
if (packing->LsbFirst) {
GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
GLubyte dstMask = 128;
const GLubyte *s = src;
GLubyte *d = dst;
*d = 0;
for (i = 0; i < width; i++) {
if (*s & srcMask) {
*d |= dstMask;
}
if (srcMask == 128) {
srcMask = 1;
s++;
}
else {
srcMask = srcMask << 1;
}
if (dstMask == 1) {
dstMask = 128;
d++;
*d = 0;
}
else {
dstMask = dstMask >> 1;
}
}
}
else {
GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
GLubyte dstMask = 128;
const GLubyte *s = src;
GLubyte *d = dst;
*d = 0;
for (i = 0; i < width; i++) {
if (*s & srcMask) {
*d |= dstMask;
}
if (srcMask == 1) {
srcMask = 128;
s++;
}
else {
srcMask = srcMask >> 1;
}
if (dstMask == 1) {
dstMask = 128;
d++;
*d = 0;
}
else {
dstMask = dstMask >> 1;
}
}
}
}
dst += width_in_bytes;
}
return buffer;
}
/*
* Pack bitmap data.
*/
void
_mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
GLubyte *dest, const struct gl_pixelstore_attrib *packing )
{
GLint row, width_in_bytes;
const GLubyte *src;
if (!source)
return;
width_in_bytes = CEILING( width, 8 );
src = source;
for (row = 0; row < height; row++) {
GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dest,
width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
if (!dst)
return;
if ((packing->SkipPixels & 7) == 0) {
memcpy( dst, src, width_in_bytes );
if (packing->LsbFirst) {
flip_bytes( dst, width_in_bytes );
}
}
else {
/* handling SkipPixels is a bit tricky (no pun intended!) */
GLint i;
if (packing->LsbFirst) {
GLubyte srcMask = 128;
GLubyte dstMask = 1 << (packing->SkipPixels & 0x7);
const GLubyte *s = src;
GLubyte *d = dst;
*d = 0;
for (i = 0; i < width; i++) {
if (*s & srcMask) {
*d |= dstMask;
}
if (srcMask == 1) {
srcMask = 128;
s++;
}
else {
srcMask = srcMask >> 1;
}
if (dstMask == 128) {
dstMask = 1;
d++;
*d = 0;
}
else {
dstMask = dstMask << 1;
}
}
}
else {
GLubyte srcMask = 128;
GLubyte dstMask = 128 >> (packing->SkipPixels & 0x7);
const GLubyte *s = src;
GLubyte *d = dst;
*d = 0;
for (i = 0; i < width; i++) {
if (*s & srcMask) {
*d |= dstMask;
}
if (srcMask == 1) {
srcMask = 128;
s++;
}
else {
srcMask = srcMask >> 1;
}
if (dstMask == 1) {
dstMask = 128;
d++;
*d = 0;
}
else {
dstMask = dstMask >> 1;
}
}
}
}
src += width_in_bytes;
}
}
/**
* Get indexes of color components for a basic color format, such as
* GL_RGBA, GL_RED, GL_LUMINANCE_ALPHA, etc. Return -1 for indexes
* that do not apply.
*/
static void
get_component_indexes(GLenum format,
GLint *redIndex,
GLint *greenIndex,
GLint *blueIndex,
GLint *alphaIndex,
GLint *luminanceIndex,
GLint *intensityIndex)
{
*redIndex = -1;
*greenIndex = -1;
*blueIndex = -1;
*alphaIndex = -1;
*luminanceIndex = -1;
*intensityIndex = -1;
switch (format) {
case GL_LUMINANCE:
case GL_LUMINANCE_INTEGER_EXT:
*luminanceIndex = 0;
break;
case GL_LUMINANCE_ALPHA:
case GL_LUMINANCE_ALPHA_INTEGER_EXT:
*luminanceIndex = 0;
*alphaIndex = 1;
break;
case GL_INTENSITY:
*intensityIndex = 0;
break;
case GL_RED:
case GL_RED_INTEGER_EXT:
*redIndex = 0;
break;
case GL_GREEN:
case GL_GREEN_INTEGER_EXT:
*greenIndex = 0;
break;
case GL_BLUE:
case GL_BLUE_INTEGER_EXT:
*blueIndex = 0;
break;
case GL_ALPHA:
case GL_ALPHA_INTEGER_EXT:
*alphaIndex = 0;
break;
case GL_RG:
case GL_RG_INTEGER:
*redIndex = 0;
*greenIndex = 1;
break;
case GL_RGB:
case GL_RGB_INTEGER_EXT:
*redIndex = 0;
*greenIndex = 1;
*blueIndex = 2;
break;
case GL_BGR:
case GL_BGR_INTEGER_EXT:
*blueIndex = 0;
*greenIndex = 1;
*redIndex = 2;
break;
case GL_RGBA:
case GL_RGBA_INTEGER_EXT:
*redIndex = 0;
*greenIndex = 1;
*blueIndex = 2;
*alphaIndex = 3;
break;
case GL_BGRA:
case GL_BGRA_INTEGER:
*redIndex = 2;
*greenIndex = 1;
*blueIndex = 0;
*alphaIndex = 3;
break;
case GL_ABGR_EXT:
*redIndex = 3;
*greenIndex = 2;
*blueIndex = 1;
*alphaIndex = 0;
break;
case GL_DU8DV8_ATI:
case GL_DUDV_ATI:
*redIndex = 0;
*greenIndex = 1;
break;
default:
assert(0 && "bad format in get_component_indexes()");
}
}
/**
* For small integer types, return the min and max possible values.
* Used for clamping floats to unscaled integer types.
* \return GL_TRUE if type is handled, GL_FALSE otherwise.
*/
static GLboolean
get_type_min_max(GLenum type, GLfloat *min, GLfloat *max)
{
switch (type) {
case GL_BYTE:
*min = -128.0;
*max = 127.0;
return GL_TRUE;
case GL_UNSIGNED_BYTE:
*min = 0.0;
*max = 255.0;
return GL_TRUE;
case GL_SHORT:
*min = -32768.0;
*max = 32767.0;
return GL_TRUE;
case GL_UNSIGNED_SHORT:
*min = 0.0;
*max = 65535.0;
return GL_TRUE;
default:
return GL_FALSE;
}
}
/* Customization of unsigned integer packing.
*/
#define SRC_TYPE GLuint
#define DST_TYPE GLuint
#define SRC_CONVERT(x) (x)
#define FN_NAME pack_uint_from_uint_rgba
#include "pack_tmp.h"
#undef DST_TYPE
#undef SRC_CONVERT
#undef FN_NAME
#define DST_TYPE GLint
#define SRC_CONVERT(x) MIN2(x, 0x7fffffff)
#define FN_NAME pack_int_from_uint_rgba
#include "pack_tmp.h"
#undef DST_TYPE
#undef SRC_CONVERT
#undef FN_NAME
#define DST_TYPE GLushort
#define SRC_CONVERT(x) MIN2(x, 0xffff)
#define FN_NAME pack_ushort_from_uint_rgba
#include "pack_tmp.h"
#undef DST_TYPE
#undef SRC_CONVERT
#undef FN_NAME
#define DST_TYPE GLshort
#define SRC_CONVERT(x) CLAMP((int)x, -32768, 32767)
#define FN_NAME pack_short_from_uint_rgba
#include "pack_tmp.h"
#undef DST_TYPE
#undef SRC_CONVERT
#undef FN_NAME
#define DST_TYPE GLubyte
#define SRC_CONVERT(x) MIN2(x, 0xff)
#define FN_NAME pack_ubyte_from_uint_rgba
#include "pack_tmp.h"
#undef DST_TYPE
#undef SRC_CONVERT
#undef FN_NAME
#define DST_TYPE GLbyte
#define SRC_CONVERT(x) CLAMP((int)x, -128, 127)
#define FN_NAME pack_byte_from_uint_rgba
#include "pack_tmp.h"
#undef DST_TYPE
#undef SRC_CONVERT
#undef FN_NAME
#undef SRC_TYPE
static void
_pack_rgba_span_from_uints_problem(struct gl_context *ctx,
GLenum dstFormat, GLenum dstType)
{
_mesa_problem(ctx,
"Unsupported type (%s) / format (%s) "
"in _mesa_pack_rgba_span_from_uints",
_mesa_lookup_enum_by_nr(dstType),
_mesa_lookup_enum_by_nr(dstFormat));
}
void
_mesa_pack_rgba_span_from_uints(struct gl_context *ctx, GLuint n, GLuint rgba[][4],
GLenum dstFormat, GLenum dstType,
GLvoid *dstAddr)
{
GLuint i;
switch(dstType) {
case GL_UNSIGNED_INT:
pack_uint_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
break;
case GL_INT:
pack_int_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
break;
case GL_UNSIGNED_SHORT:
pack_ushort_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
break;
case GL_SHORT:
pack_short_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
break;
case GL_UNSIGNED_BYTE:
pack_ubyte_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
break;
case GL_BYTE:
pack_byte_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
break;
case GL_UNSIGNED_BYTE_3_3_2:
if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
GLubyte *dst = (GLubyte *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 7) << 5)
| (CLAMP(rgba[i][GCOMP], 0, 7) << 2)
| (CLAMP(rgba[i][BCOMP], 0, 3) );
}
} else {
_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_BYTE_2_3_3_REV:
if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
GLubyte *dst = (GLubyte *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 7) )
| (CLAMP(rgba[i][GCOMP], 0, 7) << 3)
| (CLAMP(rgba[i][BCOMP], 0, 3) << 6);
}
} else {
_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_SHORT_5_6_5:
if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31) << 11)
| (CLAMP(rgba[i][GCOMP], 0, 63) << 5)
| (CLAMP(rgba[i][BCOMP], 0, 31) );
}
} else {
_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_SHORT_5_6_5_REV:
if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31) )
| (CLAMP(rgba[i][GCOMP], 0, 63) << 5)
| (CLAMP(rgba[i][BCOMP], 0, 31) << 11);
}
} else {
_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_SHORT_4_4_4_4:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 15) << 12)
| (CLAMP(rgba[i][GCOMP], 0, 15) << 8)
| (CLAMP(rgba[i][BCOMP], 0, 15) << 4)
| (CLAMP(rgba[i][ACOMP], 0, 15) );
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 15) << 12)
| (CLAMP(rgba[i][GCOMP], 0, 15) << 8)
| (CLAMP(rgba[i][RCOMP], 0, 15) << 4)
| (CLAMP(rgba[i][ACOMP], 0, 15) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 15) << 12)
| (CLAMP(rgba[i][BCOMP], 0, 15) << 8)
| (CLAMP(rgba[i][GCOMP], 0, 15) << 4)
| (CLAMP(rgba[i][RCOMP], 0, 15) );
}
} else {
_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_SHORT_4_4_4_4_REV:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 15) )
| (CLAMP(rgba[i][GCOMP], 0, 15) << 4)
| (CLAMP(rgba[i][BCOMP], 0, 15) << 8)
| (CLAMP(rgba[i][ACOMP], 0, 15) << 12);
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 15) )
| (CLAMP(rgba[i][GCOMP], 0, 15) << 4)
| (CLAMP(rgba[i][RCOMP], 0, 15) << 8)
| (CLAMP(rgba[i][ACOMP], 0, 15) << 12);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 15) )
| (CLAMP(rgba[i][BCOMP], 0, 15) << 4)
| (CLAMP(rgba[i][GCOMP], 0, 15) << 8)
| (CLAMP(rgba[i][RCOMP], 0, 15) << 12);
}
} else {
_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_SHORT_5_5_5_1:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31) << 11)
| (CLAMP(rgba[i][GCOMP], 0, 31) << 6)
| (CLAMP(rgba[i][BCOMP], 0, 31) << 1)
| (CLAMP(rgba[i][ACOMP], 0, 1) );
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 31) << 11)
| (CLAMP(rgba[i][GCOMP], 0, 31) << 6)
| (CLAMP(rgba[i][RCOMP], 0, 31) << 1)
| (CLAMP(rgba[i][ACOMP], 0, 1) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 31) << 11)
| (CLAMP(rgba[i][BCOMP], 0, 31) << 6)
| (CLAMP(rgba[i][GCOMP], 0, 31) << 1)
| (CLAMP(rgba[i][RCOMP], 0, 1) );
}
} else {
_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_SHORT_1_5_5_5_REV:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31) )
| (CLAMP(rgba[i][GCOMP], 0, 31) << 5)
| (CLAMP(rgba[i][BCOMP], 0, 31) << 10)
| (CLAMP(rgba[i][ACOMP], 0, 1) << 15);
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 31) )
| (CLAMP(rgba[i][GCOMP], 0, 31) << 5)
| (CLAMP(rgba[i][RCOMP], 0, 31) << 10)
| (CLAMP(rgba[i][ACOMP], 0, 1) << 15);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 31) )
| (CLAMP(rgba[i][BCOMP], 0, 31) << 5)
| (CLAMP(rgba[i][GCOMP], 0, 31) << 10)
| (CLAMP(rgba[i][RCOMP], 0, 1) << 15);
}
} else {
_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_INT_8_8_8_8:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 255) << 24)
| (CLAMP(rgba[i][GCOMP], 0, 255) << 16)
| (CLAMP(rgba[i][BCOMP], 0, 255) << 8)
| (CLAMP(rgba[i][ACOMP], 0, 255) );
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 255) << 24)
| (CLAMP(rgba[i][GCOMP], 0, 255) << 16)
| (CLAMP(rgba[i][RCOMP], 0, 255) << 8)
| (CLAMP(rgba[i][ACOMP], 0, 255) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 255) << 24)
| (CLAMP(rgba[i][BCOMP], 0, 255) << 16)
| (CLAMP(rgba[i][GCOMP], 0, 255) << 8)
| (CLAMP(rgba[i][RCOMP], 0, 255) );
}
} else {
_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_INT_8_8_8_8_REV:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 255) )
| (CLAMP(rgba[i][GCOMP], 0, 255) << 8)
| (CLAMP(rgba[i][BCOMP], 0, 255) << 16)
| (CLAMP(rgba[i][ACOMP], 0, 255) << 24);
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 255) )
| (CLAMP(rgba[i][GCOMP], 0, 255) << 8)
| (CLAMP(rgba[i][RCOMP], 0, 255) << 16)
| (CLAMP(rgba[i][ACOMP], 0, 255) << 24);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 255) )
| (CLAMP(rgba[i][BCOMP], 0, 255) << 8)
| (CLAMP(rgba[i][GCOMP], 0, 255) << 16)
| (CLAMP(rgba[i][RCOMP], 0, 255) << 24);
}
} else {
_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_INT_10_10_10_2:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 1023) << 22)
| (CLAMP(rgba[i][GCOMP], 0, 1023) << 12)
| (CLAMP(rgba[i][BCOMP], 0, 1023) << 2)
| (CLAMP(rgba[i][ACOMP], 0, 3) );
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 1023) << 22)
| (CLAMP(rgba[i][GCOMP], 0, 1023) << 12)
| (CLAMP(rgba[i][RCOMP], 0, 1023) << 2)
| (CLAMP(rgba[i][ACOMP], 0, 3) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 1023) << 22)
| (CLAMP(rgba[i][BCOMP], 0, 1023) << 12)
| (CLAMP(rgba[i][GCOMP], 0, 1023) << 2)
| (CLAMP(rgba[i][RCOMP], 0, 3) );
}
} else {
_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_INT_2_10_10_10_REV:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 1023) )
| (CLAMP(rgba[i][GCOMP], 0, 1023) << 10)
| (CLAMP(rgba[i][BCOMP], 0, 1023) << 20)
| (CLAMP(rgba[i][ACOMP], 0, 3) << 30);
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 1023) )
| (CLAMP(rgba[i][GCOMP], 0, 1023) << 10)
| (CLAMP(rgba[i][RCOMP], 0, 1023) << 20)
| (CLAMP(rgba[i][ACOMP], 0, 3) << 30);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 1023) )
| (CLAMP(rgba[i][BCOMP], 0, 1023) << 10)
| (CLAMP(rgba[i][GCOMP], 0, 1023) << 20)
| (CLAMP(rgba[i][RCOMP], 0, 3) << 30);
}
} else {
_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
}
break;
default:
_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
return;
}
}
/* Customization of signed integer packing.
*/
#define SRC_TYPE GLint
#define DST_TYPE GLuint
#define SRC_CONVERT(x) MAX2(x, 0)
#define FN_NAME pack_uint_from_int_rgba
#include "pack_tmp.h"
#undef DST_TYPE
#undef SRC_CONVERT
#undef FN_NAME
#define DST_TYPE GLushort
#define SRC_CONVERT(x) MAX2(x, 0)
#define FN_NAME pack_ushort_from_int_rgba
#include "pack_tmp.h"
#undef DST_TYPE
#undef SRC_CONVERT
#undef FN_NAME
#define DST_TYPE GLshort
#define SRC_CONVERT(x) CLAMP(x, -0x8000, 0x7fff)
#define FN_NAME pack_short_from_int_rgba
#include "pack_tmp.h"
#undef DST_TYPE
#undef SRC_CONVERT
#undef FN_NAME
#define DST_TYPE GLubyte
#define SRC_CONVERT(x) MAX2(x, 0)
#define FN_NAME pack_ubyte_from_int_rgba
#include "pack_tmp.h"
#undef DST_TYPE
#undef SRC_CONVERT
#undef FN_NAME
#define DST_TYPE GLbyte
#define SRC_CONVERT(x) CLAMP(x, -0x80, 0x7f)
#define FN_NAME pack_byte_from_int_rgba
#include "pack_tmp.h"
#undef DST_TYPE
#undef SRC_CONVERT
#undef FN_NAME
#undef SRC_TYPE
static void
_pack_rgba_span_from_ints_problem(struct gl_context *ctx,
GLenum dstFormat, GLenum dstType)
{
_mesa_problem(ctx,
"Unsupported type (%s) / format (%s) "
"in _mesa_pack_rgba_span_from_ints",
_mesa_lookup_enum_by_nr(dstType),
_mesa_lookup_enum_by_nr(dstFormat));
}
void
_mesa_pack_rgba_span_from_ints(struct gl_context *ctx, GLuint n, GLint rgba[][4],
GLenum dstFormat, GLenum dstType,
GLvoid *dstAddr)
{
GLuint i;
switch(dstType) {
case GL_UNSIGNED_INT:
pack_uint_from_int_rgba(ctx, dstAddr, dstFormat, rgba, n);
break;
case GL_INT:
/* No conversion necessary. */
pack_uint_from_uint_rgba(ctx, dstAddr, dstFormat, (GLuint (*)[4]) rgba, n);
break;
case GL_UNSIGNED_SHORT:
pack_ushort_from_int_rgba(ctx, dstAddr, dstFormat, rgba, n);
break;
case GL_SHORT:
pack_short_from_int_rgba(ctx, dstAddr, dstFormat, rgba, n);
break;
case GL_UNSIGNED_BYTE:
pack_ubyte_from_int_rgba(ctx, dstAddr, dstFormat, rgba, n);
break;
case GL_BYTE:
pack_byte_from_int_rgba(ctx, dstAddr, dstFormat, rgba, n);
break;
case GL_UNSIGNED_BYTE_3_3_2:
if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
GLubyte *dst = (GLubyte *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 7) << 5)
| (CLAMP(rgba[i][GCOMP], 0, 7) << 2)
| (CLAMP(rgba[i][BCOMP], 0, 3) );
}
} else {
_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_BYTE_2_3_3_REV:
if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
GLubyte *dst = (GLubyte *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 7) )
| (CLAMP(rgba[i][GCOMP], 0, 7) << 3)
| (CLAMP(rgba[i][BCOMP], 0, 3) << 6);
}
} else {
_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_SHORT_5_6_5:
if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31) << 11)
| (CLAMP(rgba[i][GCOMP], 0, 63) << 5)
| (CLAMP(rgba[i][BCOMP], 0, 31) );
}
} else {
_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_SHORT_5_6_5_REV:
if ((dstFormat == GL_RGB) || (dstFormat == GL_RGB_INTEGER)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31) )
| (CLAMP(rgba[i][GCOMP], 0, 63) << 5)
| (CLAMP(rgba[i][BCOMP], 0, 31) << 11);
}
} else {
_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_SHORT_4_4_4_4:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 15) << 12)
| (CLAMP(rgba[i][GCOMP], 0, 15) << 8)
| (CLAMP(rgba[i][BCOMP], 0, 15) << 4)
| (CLAMP(rgba[i][ACOMP], 0, 15) );
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 15) << 12)
| (CLAMP(rgba[i][GCOMP], 0, 15) << 8)
| (CLAMP(rgba[i][RCOMP], 0, 15) << 4)
| (CLAMP(rgba[i][ACOMP], 0, 15) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 15) << 12)
| (CLAMP(rgba[i][BCOMP], 0, 15) << 8)
| (CLAMP(rgba[i][GCOMP], 0, 15) << 4)
| (CLAMP(rgba[i][RCOMP], 0, 15) );
}
} else {
_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_SHORT_4_4_4_4_REV:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 15) )
| (CLAMP(rgba[i][GCOMP], 0, 15) << 4)
| (CLAMP(rgba[i][BCOMP], 0, 15) << 8)
| (CLAMP(rgba[i][ACOMP], 0, 15) << 12);
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 15) )
| (CLAMP(rgba[i][GCOMP], 0, 15) << 4)
| (CLAMP(rgba[i][RCOMP], 0, 15) << 8)
| (CLAMP(rgba[i][ACOMP], 0, 15) << 12);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 15) )
| (CLAMP(rgba[i][BCOMP], 0, 15) << 4)
| (CLAMP(rgba[i][GCOMP], 0, 15) << 8)
| (CLAMP(rgba[i][RCOMP], 0, 15) << 12);
}
} else {
_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_SHORT_5_5_5_1:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31) << 11)
| (CLAMP(rgba[i][GCOMP], 0, 31) << 6)
| (CLAMP(rgba[i][BCOMP], 0, 31) << 1)
| (CLAMP(rgba[i][ACOMP], 0, 1) );
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 31) << 11)
| (CLAMP(rgba[i][GCOMP], 0, 31) << 6)
| (CLAMP(rgba[i][RCOMP], 0, 31) << 1)
| (CLAMP(rgba[i][ACOMP], 0, 1) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 31) << 11)
| (CLAMP(rgba[i][BCOMP], 0, 31) << 6)
| (CLAMP(rgba[i][GCOMP], 0, 31) << 1)
| (CLAMP(rgba[i][RCOMP], 0, 1) );
}
} else {
_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_SHORT_1_5_5_5_REV:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31) )
| (CLAMP(rgba[i][GCOMP], 0, 31) << 5)
| (CLAMP(rgba[i][BCOMP], 0, 31) << 10)
| (CLAMP(rgba[i][ACOMP], 0, 1) << 15);
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 31) )
| (CLAMP(rgba[i][GCOMP], 0, 31) << 5)
| (CLAMP(rgba[i][RCOMP], 0, 31) << 10)
| (CLAMP(rgba[i][ACOMP], 0, 1) << 15);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 31) )
| (CLAMP(rgba[i][BCOMP], 0, 31) << 5)
| (CLAMP(rgba[i][GCOMP], 0, 31) << 10)
| (CLAMP(rgba[i][RCOMP], 0, 1) << 15);
}
} else {
_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_INT_8_8_8_8:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 255) << 24)
| (CLAMP(rgba[i][GCOMP], 0, 255) << 16)
| (CLAMP(rgba[i][BCOMP], 0, 255) << 8)
| (CLAMP(rgba[i][ACOMP], 0, 255) );
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 255) << 24)
| (CLAMP(rgba[i][GCOMP], 0, 255) << 16)
| (CLAMP(rgba[i][RCOMP], 0, 255) << 8)
| (CLAMP(rgba[i][ACOMP], 0, 255) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 255) << 24)
| (CLAMP(rgba[i][BCOMP], 0, 255) << 16)
| (CLAMP(rgba[i][GCOMP], 0, 255) << 8)
| (CLAMP(rgba[i][RCOMP], 0, 255) );
}
} else {
_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_INT_8_8_8_8_REV:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 255) )
| (CLAMP(rgba[i][GCOMP], 0, 255) << 8)
| (CLAMP(rgba[i][BCOMP], 0, 255) << 16)
| (CLAMP(rgba[i][ACOMP], 0, 255) << 24);
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 255) )
| (CLAMP(rgba[i][GCOMP], 0, 255) << 8)
| (CLAMP(rgba[i][RCOMP], 0, 255) << 16)
| (CLAMP(rgba[i][ACOMP], 0, 255) << 24);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 255) )
| (CLAMP(rgba[i][BCOMP], 0, 255) << 8)
| (CLAMP(rgba[i][GCOMP], 0, 255) << 16)
| (CLAMP(rgba[i][RCOMP], 0, 255) << 24);
}
} else {
_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_INT_10_10_10_2:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 1023) << 22)
| (CLAMP(rgba[i][GCOMP], 0, 1023) << 12)
| (CLAMP(rgba[i][BCOMP], 0, 1023) << 2)
| (CLAMP(rgba[i][ACOMP], 0, 3) );
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 1023) << 22)
| (CLAMP(rgba[i][GCOMP], 0, 1023) << 12)
| (CLAMP(rgba[i][RCOMP], 0, 1023) << 2)
| (CLAMP(rgba[i][ACOMP], 0, 3) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 1023) << 22)
| (CLAMP(rgba[i][BCOMP], 0, 1023) << 12)
| (CLAMP(rgba[i][GCOMP], 0, 1023) << 2)
| (CLAMP(rgba[i][RCOMP], 0, 3) );
}
} else {
_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
}
break;
case GL_UNSIGNED_INT_2_10_10_10_REV:
if ((dstFormat == GL_RGBA) || (dstFormat == GL_RGBA_INTEGER_EXT)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][RCOMP], 0, 1023) )
| (CLAMP(rgba[i][GCOMP], 0, 1023) << 10)
| (CLAMP(rgba[i][BCOMP], 0, 1023) << 20)
| (CLAMP(rgba[i][ACOMP], 0, 3) << 30);
}
}
else if ((dstFormat == GL_BGRA) || (dstFormat == GL_BGRA_INTEGER)) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][BCOMP], 0, 1023) )
| (CLAMP(rgba[i][GCOMP], 0, 1023) << 10)
| (CLAMP(rgba[i][RCOMP], 0, 1023) << 20)
| (CLAMP(rgba[i][ACOMP], 0, 3) << 30);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (CLAMP(rgba[i][ACOMP], 0, 1023) )
| (CLAMP(rgba[i][BCOMP], 0, 1023) << 10)
| (CLAMP(rgba[i][GCOMP], 0, 1023) << 20)
| (CLAMP(rgba[i][RCOMP], 0, 3) << 30);
}
} else {
_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
}
break;
default:
_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
return;
}
}
/**
* Used to pack an array [][4] of RGBA float colors as specified
* by the dstFormat, dstType and dstPacking. Used by glReadPixels.
* Historically, the RGBA values were in [0,1] and rescaled to fit
* into GLubytes, etc. But with new integer formats, the RGBA values
* may have any value and we don't always rescale when converting to
* integers.
*
* Note: the rgba values will be modified by this function when any pixel
* transfer ops are enabled.
*/
void
_mesa_pack_rgba_span_float(struct gl_context *ctx, GLuint n, GLfloat rgba[][4],
GLenum dstFormat, GLenum dstType,
GLvoid *dstAddr,
const struct gl_pixelstore_attrib *dstPacking,
GLbitfield transferOps)
{
GLfloat *luminance;
const GLint comps = _mesa_components_in_format(dstFormat);
const GLboolean intDstFormat = _mesa_is_enum_format_integer(dstFormat);
GLuint i;
if (dstFormat == GL_LUMINANCE ||
dstFormat == GL_LUMINANCE_ALPHA ||
dstFormat == GL_LUMINANCE_INTEGER_EXT ||
dstFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT) {
luminance = (GLfloat *) malloc(n * sizeof(GLfloat));
if (!luminance) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
return;
}
}
else {
luminance = NULL;
}
/* EXT_texture_integer specifies no transfer ops on integer
* types in the resolved issues section. Just set them to 0
* for integer surfaces.
*/
if (intDstFormat)
transferOps = 0;
if (transferOps) {
_mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
}
/*
* Component clamping (besides clamping to [0,1] in
* _mesa_apply_rgba_transfer_ops()).
*/
if (intDstFormat) {
/* clamping to dest type's min/max values */
GLfloat min, max;
if (get_type_min_max(dstType, &min, &max)) {
for (i = 0; i < n; i++) {
rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], min, max);
rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], min, max);
rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], min, max);
rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], min, max);
}
}
}
else if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {
/* compute luminance values */
if (transferOps & IMAGE_CLAMP_BIT) {
for (i = 0; i < n; i++) {
GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
luminance[i] = CLAMP(sum, 0.0F, 1.0F);
}
}
else {
for (i = 0; i < n; i++) {
luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
}
}
}
/*
* Pack/store the pixels. Ugh! Lots of cases!!!
*/
switch (dstType) {
case GL_UNSIGNED_BYTE:
{
GLubyte *dst = (GLubyte *) dstAddr;
switch (dstFormat) {
case GL_RED:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
break;
case GL_GREEN:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
break;
case GL_BLUE:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
break;
case GL_ALPHA:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
break;
case GL_LUMINANCE:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_UBYTE(luminance[i]);
break;
case GL_LUMINANCE_ALPHA:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
}
break;
case GL_RG:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
}
break;
case GL_RGB:
for (i=0;i<n;i++) {
dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
}
break;
case GL_RGBA:
for (i=0;i<n;i++) {
dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
}
break;
case GL_BGR:
for (i=0;i<n;i++) {
dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
}
break;
case GL_BGRA:
for (i=0;i<n;i++) {
dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
}
break;
case GL_ABGR_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
}
break;
case GL_RED_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLubyte) rgba[i][RCOMP];
}
break;
case GL_GREEN_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLubyte) rgba[i][GCOMP];
}
break;
case GL_BLUE_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLubyte) rgba[i][BCOMP];
}
break;
case GL_ALPHA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLubyte) rgba[i][ACOMP];
}
break;
case GL_RG_INTEGER:
for (i=0;i<n;i++) {
dst[i*2+0] = (GLubyte) rgba[i][RCOMP];
dst[i*2+1] = (GLubyte) rgba[i][GCOMP];
}
break;
case GL_RGB_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*3+0] = (GLubyte) rgba[i][RCOMP];
dst[i*3+1] = (GLubyte) rgba[i][GCOMP];
dst[i*3+2] = (GLubyte) rgba[i][BCOMP];
}
break;
case GL_RGBA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = (GLubyte) rgba[i][RCOMP];
dst[i*4+1] = (GLubyte) rgba[i][GCOMP];
dst[i*4+2] = (GLubyte) rgba[i][BCOMP];
dst[i*4+3] = (GLubyte) rgba[i][ACOMP];
}
break;
case GL_BGR_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*3+0] = (GLubyte) rgba[i][BCOMP];
dst[i*3+1] = (GLubyte) rgba[i][GCOMP];
dst[i*3+2] = (GLubyte) rgba[i][RCOMP];
}
break;
case GL_BGRA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = (GLubyte) rgba[i][BCOMP];
dst[i*4+1] = (GLubyte) rgba[i][GCOMP];
dst[i*4+2] = (GLubyte) rgba[i][RCOMP];
dst[i*4+3] = (GLubyte) rgba[i][ACOMP];
}
break;
case GL_LUMINANCE_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*2+0] = (GLubyte) (rgba[i][RCOMP] +
rgba[i][GCOMP] +
rgba[i][BCOMP]);
dst[i*2+1] = (GLubyte) rgba[i][ACOMP];
}
break;
case GL_LUMINANCE_ALPHA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLubyte) (rgba[i][RCOMP] +
rgba[i][GCOMP] +
rgba[i][BCOMP]);
}
break;
case GL_DUDV_ATI:
case GL_DU8DV8_ATI:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
}
break;
default:
_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
}
}
break;
case GL_BYTE:
{
GLbyte *dst = (GLbyte *) dstAddr;
switch (dstFormat) {
case GL_RED:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
break;
case GL_GREEN:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
break;
case GL_BLUE:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
break;
case GL_ALPHA:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
break;
case GL_LUMINANCE:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_BYTE(luminance[i]);
break;
case GL_LUMINANCE_ALPHA:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
}
break;
case GL_RG:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
}
break;
case GL_RGB:
for (i=0;i<n;i++) {
dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
}
break;
case GL_RGBA:
for (i=0;i<n;i++) {
dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
}
break;
case GL_BGR:
for (i=0;i<n;i++) {
dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
}
break;
case GL_BGRA:
for (i=0;i<n;i++) {
dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
}
break;
case GL_ABGR_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
}
break;
case GL_RED_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLbyte) rgba[i][RCOMP];
}
break;
case GL_GREEN_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLbyte) rgba[i][GCOMP];
}
break;
case GL_BLUE_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLbyte) rgba[i][BCOMP];
}
break;
case GL_ALPHA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLbyte) rgba[i][ACOMP];
}
break;
case GL_RG_INTEGER:
for (i=0;i<n;i++) {
dst[i*2+0] = (GLbyte) rgba[i][RCOMP];
dst[i*2+1] = (GLbyte) rgba[i][GCOMP];
}
break;
case GL_RGB_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*3+0] = (GLbyte) rgba[i][RCOMP];
dst[i*3+1] = (GLbyte) rgba[i][GCOMP];
dst[i*3+2] = (GLbyte) rgba[i][BCOMP];
}
break;
case GL_RGBA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = (GLbyte) rgba[i][RCOMP];
dst[i*4+1] = (GLbyte) rgba[i][GCOMP];
dst[i*4+2] = (GLbyte) rgba[i][BCOMP];
dst[i*4+3] = (GLbyte) rgba[i][ACOMP];
}
break;
case GL_BGR_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*3+0] = (GLbyte) rgba[i][BCOMP];
dst[i*3+1] = (GLbyte) rgba[i][GCOMP];
dst[i*3+2] = (GLbyte) rgba[i][RCOMP];
}
break;
case GL_BGRA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = (GLbyte) rgba[i][BCOMP];
dst[i*4+1] = (GLbyte) rgba[i][GCOMP];
dst[i*4+2] = (GLbyte) rgba[i][RCOMP];
dst[i*4+3] = (GLbyte) rgba[i][ACOMP];
}
break;
case GL_LUMINANCE_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*2+0] = (GLbyte) (rgba[i][RCOMP] +
rgba[i][GCOMP] +
rgba[i][BCOMP]);
dst[i*2+1] = (GLbyte) rgba[i][ACOMP];
}
break;
case GL_LUMINANCE_ALPHA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLbyte) (rgba[i][RCOMP] +
rgba[i][GCOMP] +
rgba[i][BCOMP]);
}
break;
case GL_DUDV_ATI:
case GL_DU8DV8_ATI:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
}
break;
default:
_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
}
}
break;
case GL_UNSIGNED_SHORT:
{
GLushort *dst = (GLushort *) dstAddr;
switch (dstFormat) {
case GL_RED:
for (i=0;i<n;i++)
CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][RCOMP]);
break;
case GL_GREEN:
for (i=0;i<n;i++)
CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][GCOMP]);
break;
case GL_BLUE:
for (i=0;i<n;i++)
CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][BCOMP]);
break;
case GL_ALPHA:
for (i=0;i<n;i++)
CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][ACOMP]);
break;
case GL_LUMINANCE:
for (i=0;i<n;i++)
UNCLAMPED_FLOAT_TO_USHORT(dst[i], luminance[i]);
break;
case GL_LUMINANCE_ALPHA:
for (i=0;i<n;i++) {
UNCLAMPED_FLOAT_TO_USHORT(dst[i*2+0], luminance[i]);
CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][ACOMP]);
}
break;
case GL_RG:
for (i=0;i<n;i++) {
CLAMPED_FLOAT_TO_USHORT(dst[i*2+0], rgba[i][RCOMP]);
CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][GCOMP]);
}
break;
case GL_RGB:
for (i=0;i<n;i++) {
CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][RCOMP]);
CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][BCOMP]);
}
break;
case GL_RGBA:
for (i=0;i<n;i++) {
CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][RCOMP]);
CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][BCOMP]);
CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
}
break;
case GL_BGR:
for (i=0;i<n;i++) {
CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][BCOMP]);
CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][RCOMP]);
}
break;
case GL_BGRA:
for (i=0;i<n;i++) {
CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][BCOMP]);
CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][RCOMP]);
CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
}
break;
case GL_ABGR_EXT:
for (i=0;i<n;i++) {
CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][ACOMP]);
CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][BCOMP]);
CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][GCOMP]);
CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]);
}
break;
case GL_RED_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLushort) rgba[i][RCOMP];
}
break;
case GL_GREEN_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLushort) rgba[i][GCOMP];
}
break;
case GL_BLUE_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLushort) rgba[i][BCOMP];
}
break;
case GL_ALPHA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLushort) rgba[i][ACOMP];
}
break;
case GL_RG_INTEGER:
for (i=0;i<n;i++) {
dst[i*2+0] = (GLushort) rgba[i][RCOMP];
dst[i*2+1] = (GLushort) rgba[i][GCOMP];
}
break;
case GL_RGB_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*3+0] = (GLushort) rgba[i][RCOMP];
dst[i*3+1] = (GLushort) rgba[i][GCOMP];
dst[i*3+2] = (GLushort) rgba[i][BCOMP];
}
break;
case GL_RGBA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = (GLushort) rgba[i][RCOMP];
dst[i*4+1] = (GLushort) rgba[i][GCOMP];
dst[i*4+2] = (GLushort) rgba[i][BCOMP];
dst[i*4+3] = (GLushort) rgba[i][ACOMP];
}
break;
case GL_BGR_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*3+0] = (GLushort) rgba[i][BCOMP];
dst[i*3+1] = (GLushort) rgba[i][GCOMP];
dst[i*3+2] = (GLushort) rgba[i][RCOMP];
}
break;
case GL_BGRA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = (GLushort) rgba[i][BCOMP];
dst[i*4+1] = (GLushort) rgba[i][GCOMP];
dst[i*4+2] = (GLushort) rgba[i][RCOMP];
dst[i*4+3] = (GLushort) rgba[i][ACOMP];
}
break;
case GL_LUMINANCE_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*2+0] = (GLushort) (rgba[i][RCOMP] +
rgba[i][GCOMP] +
rgba[i][BCOMP]);
dst[i*2+1] = (GLushort) rgba[i][ACOMP];
}
break;
case GL_LUMINANCE_ALPHA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLushort) (rgba[i][RCOMP] +
rgba[i][GCOMP] +
rgba[i][BCOMP]);
}
break;
case GL_DUDV_ATI:
case GL_DU8DV8_ATI:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
}
break;
default:
_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
}
}
break;
case GL_SHORT:
{
GLshort *dst = (GLshort *) dstAddr;
switch (dstFormat) {
case GL_RED:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
break;
case GL_GREEN:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
break;
case GL_BLUE:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
break;
case GL_ALPHA:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
break;
case GL_LUMINANCE:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_SHORT(luminance[i]);
break;
case GL_LUMINANCE_ALPHA:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
}
break;
case GL_RG:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
}
break;
case GL_RGB:
for (i=0;i<n;i++) {
dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
}
break;
case GL_RGBA:
for (i=0;i<n;i++) {
dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
}
break;
case GL_BGR:
for (i=0;i<n;i++) {
dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
}
break;
case GL_BGRA:
for (i=0;i<n;i++) {
dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
}
break;
case GL_ABGR_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
}
break;
case GL_RED_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLshort) rgba[i][RCOMP];
}
break;
case GL_GREEN_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLshort) rgba[i][GCOMP];
}
break;
case GL_BLUE_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLshort) rgba[i][BCOMP];
}
break;
case GL_ALPHA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLshort) rgba[i][ACOMP];
}
break;
case GL_RG_INTEGER:
for (i=0;i<n;i++) {
dst[i*2+0] = (GLshort) rgba[i][RCOMP];
dst[i*2+1] = (GLshort) rgba[i][GCOMP];
}
break;
case GL_RGB_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*3+0] = (GLshort) rgba[i][RCOMP];
dst[i*3+1] = (GLshort) rgba[i][GCOMP];
dst[i*3+2] = (GLshort) rgba[i][BCOMP];
}
break;
case GL_RGBA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = (GLshort) rgba[i][RCOMP];
dst[i*4+1] = (GLshort) rgba[i][GCOMP];
dst[i*4+2] = (GLshort) rgba[i][BCOMP];
dst[i*4+3] = (GLshort) rgba[i][ACOMP];
}
break;
case GL_BGR_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*3+0] = (GLshort) rgba[i][BCOMP];
dst[i*3+1] = (GLshort) rgba[i][GCOMP];
dst[i*3+2] = (GLshort) rgba[i][RCOMP];
}
break;
case GL_BGRA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = (GLshort) rgba[i][BCOMP];
dst[i*4+1] = (GLshort) rgba[i][GCOMP];
dst[i*4+2] = (GLshort) rgba[i][RCOMP];
dst[i*4+3] = (GLshort) rgba[i][ACOMP];
}
break;
case GL_LUMINANCE_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*2+0] = (GLshort) (rgba[i][RCOMP] +
rgba[i][GCOMP] +
rgba[i][BCOMP]);
dst[i*2+1] = (GLshort) rgba[i][ACOMP];
}
break;
case GL_LUMINANCE_ALPHA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLshort) (rgba[i][RCOMP] +
rgba[i][GCOMP] +
rgba[i][BCOMP]);
}
break;
case GL_DUDV_ATI:
case GL_DU8DV8_ATI:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
}
break;
default:
_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
}
}
break;
case GL_UNSIGNED_INT:
{
GLuint *dst = (GLuint *) dstAddr;
switch (dstFormat) {
case GL_RED:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
break;
case GL_GREEN:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
break;
case GL_BLUE:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
break;
case GL_ALPHA:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
break;
case GL_LUMINANCE:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_UINT(luminance[i]);
break;
case GL_LUMINANCE_ALPHA:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
}
break;
case GL_RG:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
}
break;
case GL_RGB:
for (i=0;i<n;i++) {
dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
}
break;
case GL_RGBA:
for (i=0;i<n;i++) {
dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
}
break;
case GL_BGR:
for (i=0;i<n;i++) {
dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
}
break;
case GL_BGRA:
for (i=0;i<n;i++) {
dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
}
break;
case GL_ABGR_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
}
break;
case GL_RED_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLuint) rgba[i][RCOMP];
}
break;
case GL_GREEN_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLuint) rgba[i][GCOMP];
}
break;
case GL_BLUE_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLuint) rgba[i][BCOMP];
}
break;
case GL_ALPHA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLuint) rgba[i][ACOMP];
}
break;
case GL_RG_INTEGER:
for (i=0;i<n;i++) {
dst[i*2+0] = (GLuint) rgba[i][RCOMP];
dst[i*2+1] = (GLuint) rgba[i][GCOMP];
}
break;
case GL_RGB_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*3+0] = (GLuint) rgba[i][RCOMP];
dst[i*3+1] = (GLuint) rgba[i][GCOMP];
dst[i*3+2] = (GLuint) rgba[i][BCOMP];
}
break;
case GL_RGBA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = (GLuint) rgba[i][RCOMP];
dst[i*4+1] = (GLuint) rgba[i][GCOMP];
dst[i*4+2] = (GLuint) rgba[i][BCOMP];
dst[i*4+3] = (GLuint) rgba[i][ACOMP];
}
break;
case GL_BGR_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*3+0] = (GLuint) rgba[i][BCOMP];
dst[i*3+1] = (GLuint) rgba[i][GCOMP];
dst[i*3+2] = (GLuint) rgba[i][RCOMP];
}
break;
case GL_BGRA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = (GLuint) rgba[i][BCOMP];
dst[i*4+1] = (GLuint) rgba[i][GCOMP];
dst[i*4+2] = (GLuint) rgba[i][RCOMP];
dst[i*4+3] = (GLuint) rgba[i][ACOMP];
}
break;
case GL_LUMINANCE_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*2+0] = (GLuint) (rgba[i][RCOMP] +
rgba[i][GCOMP] +
rgba[i][BCOMP]);
dst[i*2+1] = (GLuint) rgba[i][ACOMP];
}
break;
case GL_LUMINANCE_ALPHA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLuint) (rgba[i][RCOMP] +
rgba[i][GCOMP] +
rgba[i][BCOMP]);
}
break;
case GL_DUDV_ATI:
case GL_DU8DV8_ATI:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
}
break;
default:
_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
}
}
break;
case GL_INT:
{
GLint *dst = (GLint *) dstAddr;
switch (dstFormat) {
case GL_RED:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
break;
case GL_GREEN:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
break;
case GL_BLUE:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
break;
case GL_ALPHA:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
break;
case GL_LUMINANCE:
for (i=0;i<n;i++)
dst[i] = FLOAT_TO_INT(luminance[i]);
break;
case GL_LUMINANCE_ALPHA:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
}
break;
case GL_RG:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
}
break;
case GL_RGB:
for (i=0;i<n;i++) {
dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
}
break;
case GL_RGBA:
for (i=0;i<n;i++) {
dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
}
break;
case GL_BGR:
for (i=0;i<n;i++) {
dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
}
break;
case GL_BGRA:
for (i=0;i<n;i++) {
dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
}
break;
case GL_ABGR_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
}
break;
case GL_DUDV_ATI:
case GL_DU8DV8_ATI:
for (i=0;i<n;i++) {
dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
}
break;
case GL_RED_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLint) rgba[i][RCOMP];
}
break;
case GL_GREEN_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLint) rgba[i][GCOMP];
}
break;
case GL_BLUE_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLint) rgba[i][BCOMP];
}
break;
case GL_ALPHA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLint) rgba[i][ACOMP];
}
break;
case GL_RG_INTEGER:
for (i=0;i<n;i++) {
dst[i*2+0] = (GLint) rgba[i][RCOMP];
dst[i*2+1] = (GLint) rgba[i][GCOMP];
}
break;
case GL_RGB_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*3+0] = (GLint) rgba[i][RCOMP];
dst[i*3+1] = (GLint) rgba[i][GCOMP];
dst[i*3+2] = (GLint) rgba[i][BCOMP];
}
break;
case GL_RGBA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = (GLint) rgba[i][RCOMP];
dst[i*4+1] = (GLint) rgba[i][GCOMP];
dst[i*4+2] = (GLint) rgba[i][BCOMP];
dst[i*4+3] = (GLint) rgba[i][ACOMP];
}
break;
case GL_BGR_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*3+0] = (GLint) rgba[i][BCOMP];
dst[i*3+1] = (GLint) rgba[i][GCOMP];
dst[i*3+2] = (GLint) rgba[i][RCOMP];
}
break;
case GL_BGRA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = (GLint) rgba[i][BCOMP];
dst[i*4+1] = (GLint) rgba[i][GCOMP];
dst[i*4+2] = (GLint) rgba[i][RCOMP];
dst[i*4+3] = (GLint) rgba[i][ACOMP];
}
break;
case GL_LUMINANCE_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i*2+0] = (GLint) (rgba[i][RCOMP] +
rgba[i][GCOMP] +
rgba[i][BCOMP]);
dst[i*2+1] = (GLint) rgba[i][ACOMP];
}
break;
case GL_LUMINANCE_ALPHA_INTEGER_EXT:
for (i=0;i<n;i++) {
dst[i] = (GLint) (rgba[i][RCOMP] +
rgba[i][GCOMP] +
rgba[i][BCOMP]);
}
break;
default:
_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
}
}
break;
case GL_FLOAT:
{
GLfloat *dst = (GLfloat *) dstAddr;
switch (dstFormat) {
case GL_RED:
for (i=0;i<n;i++)
dst[i] = rgba[i][RCOMP];
break;
case GL_GREEN:
for (i=0;i<n;i++)
dst[i] = rgba[i][GCOMP];
break;
case GL_BLUE:
for (i=0;i<n;i++)
dst[i] = rgba[i][BCOMP];
break;
case GL_ALPHA:
for (i=0;i<n;i++)
dst[i] = rgba[i][ACOMP];
break;
case GL_LUMINANCE:
for (i=0;i<n;i++)
dst[i] = luminance[i];
break;
case GL_LUMINANCE_ALPHA:
for (i=0;i<n;i++) {
dst[i*2+0] = luminance[i];
dst[i*2+1] = rgba[i][ACOMP];
}
break;
case GL_RG:
for (i=0;i<n;i++) {
dst[i*2+0] = rgba[i][RCOMP];
dst[i*2+1] = rgba[i][GCOMP];
}
break;
case GL_RGB:
for (i=0;i<n;i++) {
dst[i*3+0] = rgba[i][RCOMP];
dst[i*3+1] = rgba[i][GCOMP];
dst[i*3+2] = rgba[i][BCOMP];
}
break;
case GL_RGBA:
for (i=0;i<n;i++) {
dst[i*4+0] = rgba[i][RCOMP];
dst[i*4+1] = rgba[i][GCOMP];
dst[i*4+2] = rgba[i][BCOMP];
dst[i*4+3] = rgba[i][ACOMP];
}
break;
case GL_BGR:
for (i=0;i<n;i++) {
dst[i*3+0] = rgba[i][BCOMP];
dst[i*3+1] = rgba[i][GCOMP];
dst[i*3+2] = rgba[i][RCOMP];
}
break;
case GL_BGRA:
for (i=0;i<n;i++) {
dst[i*4+0] = rgba[i][BCOMP];
dst[i*4+1] = rgba[i][GCOMP];
dst[i*4+2] = rgba[i][RCOMP];
dst[i*4+3] = rgba[i][ACOMP];
}
break;
case GL_ABGR_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = rgba[i][ACOMP];
dst[i*4+1] = rgba[i][BCOMP];
dst[i*4+2] = rgba[i][GCOMP];
dst[i*4+3] = rgba[i][RCOMP];
}
break;
case GL_DUDV_ATI:
case GL_DU8DV8_ATI:
for (i=0;i<n;i++) {
dst[i*2+0] = rgba[i][RCOMP];
dst[i*2+1] = rgba[i][GCOMP];
}
break;
default:
_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
}
}
break;
case GL_HALF_FLOAT_ARB:
{
GLhalfARB *dst = (GLhalfARB *) dstAddr;
switch (dstFormat) {
case GL_RED:
for (i=0;i<n;i++)
dst[i] = _mesa_float_to_half(rgba[i][RCOMP]);
break;
case GL_GREEN:
for (i=0;i<n;i++)
dst[i] = _mesa_float_to_half(rgba[i][GCOMP]);
break;
case GL_BLUE:
for (i=0;i<n;i++)
dst[i] = _mesa_float_to_half(rgba[i][BCOMP]);
break;
case GL_ALPHA:
for (i=0;i<n;i++)
dst[i] = _mesa_float_to_half(rgba[i][ACOMP]);
break;
case GL_LUMINANCE:
for (i=0;i<n;i++)
dst[i] = _mesa_float_to_half(luminance[i]);
break;
case GL_LUMINANCE_ALPHA:
for (i=0;i<n;i++) {
dst[i*2+0] = _mesa_float_to_half(luminance[i]);
dst[i*2+1] = _mesa_float_to_half(rgba[i][ACOMP]);
}
break;
case GL_RG:
for (i=0;i<n;i++) {
dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
}
break;
case GL_RGB:
for (i=0;i<n;i++) {
dst[i*3+0] = _mesa_float_to_half(rgba[i][RCOMP]);
dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
dst[i*3+2] = _mesa_float_to_half(rgba[i][BCOMP]);
}
break;
case GL_RGBA:
for (i=0;i<n;i++) {
dst[i*4+0] = _mesa_float_to_half(rgba[i][RCOMP]);
dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
dst[i*4+2] = _mesa_float_to_half(rgba[i][BCOMP]);
dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
}
break;
case GL_BGR:
for (i=0;i<n;i++) {
dst[i*3+0] = _mesa_float_to_half(rgba[i][BCOMP]);
dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
dst[i*3+2] = _mesa_float_to_half(rgba[i][RCOMP]);
}
break;
case GL_BGRA:
for (i=0;i<n;i++) {
dst[i*4+0] = _mesa_float_to_half(rgba[i][BCOMP]);
dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
dst[i*4+2] = _mesa_float_to_half(rgba[i][RCOMP]);
dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
}
break;
case GL_ABGR_EXT:
for (i=0;i<n;i++) {
dst[i*4+0] = _mesa_float_to_half(rgba[i][ACOMP]);
dst[i*4+1] = _mesa_float_to_half(rgba[i][BCOMP]);
dst[i*4+2] = _mesa_float_to_half(rgba[i][GCOMP]);
dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]);
}
break;
case GL_DUDV_ATI:
case GL_DU8DV8_ATI:
for (i=0;i<n;i++) {
dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
}
break;
default:
_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
}
}
break;
case GL_UNSIGNED_BYTE_3_3_2:
if (dstFormat == GL_RGB) {
GLubyte *dst = (GLubyte *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][RCOMP] * 7.0F) << 5)
| (F_TO_I(rgba[i][GCOMP] * 7.0F) << 2)
| (F_TO_I(rgba[i][BCOMP] * 3.0F) );
}
}
break;
case GL_UNSIGNED_BYTE_2_3_3_REV:
if (dstFormat == GL_RGB) {
GLubyte *dst = (GLubyte *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][RCOMP] * 7.0F) )
| (F_TO_I(rgba[i][GCOMP] * 7.0F) << 3)
| (F_TO_I(rgba[i][BCOMP] * 3.0F) << 6);
}
}
break;
case GL_UNSIGNED_SHORT_5_6_5:
if (dstFormat == GL_RGB) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F) << 11)
| (F_TO_I(rgba[i][GCOMP] * 63.0F) << 5)
| (F_TO_I(rgba[i][BCOMP] * 31.0F) );
}
}
break;
case GL_UNSIGNED_SHORT_5_6_5_REV:
if (dstFormat == GL_RGB) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F) )
| (F_TO_I(rgba[i][GCOMP] * 63.0F) << 5)
| (F_TO_I(rgba[i][BCOMP] * 31.0F) << 11);
}
}
break;
case GL_UNSIGNED_SHORT_4_4_4_4:
if (dstFormat == GL_RGBA) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][RCOMP] * 15.0F) << 12)
| (F_TO_I(rgba[i][GCOMP] * 15.0F) << 8)
| (F_TO_I(rgba[i][BCOMP] * 15.0F) << 4)
| (F_TO_I(rgba[i][ACOMP] * 15.0F) );
}
}
else if (dstFormat == GL_BGRA) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][BCOMP] * 15.0F) << 12)
| (F_TO_I(rgba[i][GCOMP] * 15.0F) << 8)
| (F_TO_I(rgba[i][RCOMP] * 15.0F) << 4)
| (F_TO_I(rgba[i][ACOMP] * 15.0F) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][ACOMP] * 15.0F) << 12)
| (F_TO_I(rgba[i][BCOMP] * 15.0F) << 8)
| (F_TO_I(rgba[i][GCOMP] * 15.0F) << 4)
| (F_TO_I(rgba[i][RCOMP] * 15.0F) );
}
}
break;
case GL_UNSIGNED_SHORT_4_4_4_4_REV:
if (dstFormat == GL_RGBA) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][RCOMP] * 15.0F) )
| (F_TO_I(rgba[i][GCOMP] * 15.0F) << 4)
| (F_TO_I(rgba[i][BCOMP] * 15.0F) << 8)
| (F_TO_I(rgba[i][ACOMP] * 15.0F) << 12);
}
}
else if (dstFormat == GL_BGRA) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][BCOMP] * 15.0F) )
| (F_TO_I(rgba[i][GCOMP] * 15.0F) << 4)
| (F_TO_I(rgba[i][RCOMP] * 15.0F) << 8)
| (F_TO_I(rgba[i][ACOMP] * 15.0F) << 12);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][ACOMP] * 15.0F) )
| (F_TO_I(rgba[i][BCOMP] * 15.0F) << 4)
| (F_TO_I(rgba[i][GCOMP] * 15.0F) << 8)
| (F_TO_I(rgba[i][RCOMP] * 15.0F) << 12);
}
}
break;
case GL_UNSIGNED_SHORT_5_5_5_1:
if (dstFormat == GL_RGBA) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F) << 11)
| (F_TO_I(rgba[i][GCOMP] * 31.0F) << 6)
| (F_TO_I(rgba[i][BCOMP] * 31.0F) << 1)
| (F_TO_I(rgba[i][ACOMP] * 1.0F) );
}
}
else if (dstFormat == GL_BGRA) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][BCOMP] * 31.0F) << 11)
| (F_TO_I(rgba[i][GCOMP] * 31.0F) << 6)
| (F_TO_I(rgba[i][RCOMP] * 31.0F) << 1)
| (F_TO_I(rgba[i][ACOMP] * 1.0F) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][ACOMP] * 31.0F) << 11)
| (F_TO_I(rgba[i][BCOMP] * 31.0F) << 6)
| (F_TO_I(rgba[i][GCOMP] * 31.0F) << 1)
| (F_TO_I(rgba[i][RCOMP] * 1.0F) );
}
}
break;
case GL_UNSIGNED_SHORT_1_5_5_5_REV:
if (dstFormat == GL_RGBA) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F) )
| (F_TO_I(rgba[i][GCOMP] * 31.0F) << 5)
| (F_TO_I(rgba[i][BCOMP] * 31.0F) << 10)
| (F_TO_I(rgba[i][ACOMP] * 1.0F) << 15);
}
}
else if (dstFormat == GL_BGRA) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][BCOMP] * 31.0F) )
| (F_TO_I(rgba[i][GCOMP] * 31.0F) << 5)
| (F_TO_I(rgba[i][RCOMP] * 31.0F) << 10)
| (F_TO_I(rgba[i][ACOMP] * 1.0F) << 15);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][ACOMP] * 31.0F) )
| (F_TO_I(rgba[i][BCOMP] * 31.0F) << 5)
| (F_TO_I(rgba[i][GCOMP] * 31.0F) << 10)
| (F_TO_I(rgba[i][RCOMP] * 1.0F) << 15);
}
}
break;
case GL_UNSIGNED_INT_8_8_8_8:
if (dstFormat == GL_RGBA) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][RCOMP] * 255.F) << 24)
| (F_TO_I(rgba[i][GCOMP] * 255.F) << 16)
| (F_TO_I(rgba[i][BCOMP] * 255.F) << 8)
| (F_TO_I(rgba[i][ACOMP] * 255.F) );
}
}
else if (dstFormat == GL_BGRA) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][BCOMP] * 255.F) << 24)
| (F_TO_I(rgba[i][GCOMP] * 255.F) << 16)
| (F_TO_I(rgba[i][RCOMP] * 255.F) << 8)
| (F_TO_I(rgba[i][ACOMP] * 255.F) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][ACOMP] * 255.F) << 24)
| (F_TO_I(rgba[i][BCOMP] * 255.F) << 16)
| (F_TO_I(rgba[i][GCOMP] * 255.F) << 8)
| (F_TO_I(rgba[i][RCOMP] * 255.F) );
}
}
break;
case GL_UNSIGNED_INT_8_8_8_8_REV:
if (dstFormat == GL_RGBA) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][RCOMP] * 255.0F) )
| (F_TO_I(rgba[i][GCOMP] * 255.0F) << 8)
| (F_TO_I(rgba[i][BCOMP] * 255.0F) << 16)
| (F_TO_I(rgba[i][ACOMP] * 255.0F) << 24);
}
}
else if (dstFormat == GL_BGRA) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][BCOMP] * 255.0F) )
| (F_TO_I(rgba[i][GCOMP] * 255.0F) << 8)
| (F_TO_I(rgba[i][RCOMP] * 255.0F) << 16)
| (F_TO_I(rgba[i][ACOMP] * 255.0F) << 24);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][ACOMP] * 255.0F) )
| (F_TO_I(rgba[i][BCOMP] * 255.0F) << 8)
| (F_TO_I(rgba[i][GCOMP] * 255.0F) << 16)
| (F_TO_I(rgba[i][RCOMP] * 255.0F) << 24);
}
}
break;
case GL_UNSIGNED_INT_10_10_10_2:
if (dstFormat == GL_RGBA) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][RCOMP] * 1023.0F) << 22)
| (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 12)
| (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 2)
| (F_TO_I(rgba[i][ACOMP] * 3.0F) );
}
}
else if (dstFormat == GL_BGRA) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 22)
| (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 12)
| (F_TO_I(rgba[i][RCOMP] * 1023.0F) << 2)
| (F_TO_I(rgba[i][ACOMP] * 3.0F) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][ACOMP] * 1023.0F) << 22)
| (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 12)
| (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 2)
| (F_TO_I(rgba[i][RCOMP] * 3.0F) );
}
}
break;
case GL_UNSIGNED_INT_2_10_10_10_REV:
if (dstFormat == GL_RGBA) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][RCOMP] * 1023.0F) )
| (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 10)
| (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 20)
| (F_TO_I(rgba[i][ACOMP] * 3.0F) << 30);
}
}
else if (dstFormat == GL_BGRA) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][BCOMP] * 1023.0F) )
| (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 10)
| (F_TO_I(rgba[i][RCOMP] * 1023.0F) << 20)
| (F_TO_I(rgba[i][ACOMP] * 3.0F) << 30);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (F_TO_I(rgba[i][ACOMP] * 1023.0F) )
| (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 10)
| (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 20)
| (F_TO_I(rgba[i][RCOMP] * 3.0F) << 30);
}
}
break;
case GL_UNSIGNED_INT_5_9_9_9_REV:
{
GLuint *dst = (GLuint *) dstAddr;
for (i = 0; i < n; i++) {
dst[i] = float3_to_rgb9e5(rgba[i]);
}
}
break;
case GL_UNSIGNED_INT_10F_11F_11F_REV:
{
GLuint *dst = (GLuint *) dstAddr;
for (i = 0; i < n; i++) {
dst[i] = float3_to_r11g11b10f(rgba[i]);
}
}
break;
default:
_mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");
free(luminance);
return;
}
if (dstPacking->SwapBytes) {
GLint swapSize = _mesa_sizeof_packed_type(dstType);
if (swapSize == 2) {
_mesa_swap2((GLushort *) dstAddr, n * comps);
}
else if (swapSize == 4) {
_mesa_swap4((GLuint *) dstAddr, n * comps);
}
}
free(luminance);
}
#define SWAP2BYTE(VALUE) \
{ \
GLubyte *bytes = (GLubyte *) &(VALUE); \
GLubyte tmp = bytes[0]; \
bytes[0] = bytes[1]; \
bytes[1] = tmp; \
}
#define SWAP4BYTE(VALUE) \
{ \
GLubyte *bytes = (GLubyte *) &(VALUE); \
GLubyte tmp = bytes[0]; \
bytes[0] = bytes[3]; \
bytes[3] = tmp; \
tmp = bytes[1]; \
bytes[1] = bytes[2]; \
bytes[2] = tmp; \
}
static void
extract_uint_indexes(GLuint n, GLuint indexes[],
GLenum srcFormat, GLenum srcType, const GLvoid *src,
const struct gl_pixelstore_attrib *unpack )
{
ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX);
ASSERT(srcType == GL_BITMAP ||
srcType == GL_UNSIGNED_BYTE ||
srcType == GL_BYTE ||
srcType == GL_UNSIGNED_SHORT ||
srcType == GL_SHORT ||
srcType == GL_UNSIGNED_INT ||
srcType == GL_INT ||
srcType == GL_UNSIGNED_INT_24_8_EXT ||
srcType == GL_HALF_FLOAT_ARB ||
srcType == GL_FLOAT ||
srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
switch (srcType) {
case GL_BITMAP:
{
GLubyte *ubsrc = (GLubyte *) src;
if (unpack->LsbFirst) {
GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
GLuint i;
for (i = 0; i < n; i++) {
indexes[i] = (*ubsrc & mask) ? 1 : 0;
if (mask == 128) {
mask = 1;
ubsrc++;
}
else {
mask = mask << 1;
}
}
}
else {
GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
GLuint i;
for (i = 0; i < n; i++) {
indexes[i] = (*ubsrc & mask) ? 1 : 0;
if (mask == 1) {
mask = 128;
ubsrc++;
}
else {
mask = mask >> 1;
}
}
}
}
break;
case GL_UNSIGNED_BYTE:
{
GLuint i;
const GLubyte *s = (const GLubyte *) src;
for (i = 0; i < n; i++)
indexes[i] = s[i];
}
break;
case GL_BYTE:
{
GLuint i;
const GLbyte *s = (const GLbyte *) src;
for (i = 0; i < n; i++)
indexes[i] = s[i];
}
break;
case GL_UNSIGNED_SHORT:
{
GLuint i;
const GLushort *s = (const GLushort *) src;
if (unpack->SwapBytes) {
for (i = 0; i < n; i++) {
GLushort value = s[i];
SWAP2BYTE(value);
indexes[i] = value;
}
}
else {
for (i = 0; i < n; i++)
indexes[i] = s[i];
}
}
break;
case GL_SHORT:
{
GLuint i;
const GLshort *s = (const GLshort *) src;
if (unpack->SwapBytes) {
for (i = 0; i < n; i++) {
GLshort value = s[i];
SWAP2BYTE(value);
indexes[i] = value;
}
}
else {
for (i = 0; i < n; i++)
indexes[i] = s[i];
}
}
break;
case GL_UNSIGNED_INT:
{
GLuint i;
const GLuint *s = (const GLuint *) src;
if (unpack->SwapBytes) {
for (i = 0; i < n; i++) {
GLuint value = s[i];
SWAP4BYTE(value);
indexes[i] = value;
}
}
else {
for (i = 0; i < n; i++)
indexes[i] = s[i];
}
}
break;
case GL_INT:
{
GLuint i;
const GLint *s = (const GLint *) src;
if (unpack->SwapBytes) {
for (i = 0; i < n; i++) {
GLint value = s[i];
SWAP4BYTE(value);
indexes[i] = value;
}
}
else {
for (i = 0; i < n; i++)
indexes[i] = s[i];
}
}
break;
case GL_FLOAT:
{
GLuint i;
const GLfloat *s = (const GLfloat *) src;
if (unpack->SwapBytes) {
for (i = 0; i < n; i++) {
GLfloat value = s[i];
SWAP4BYTE(value);
indexes[i] = (GLuint) value;
}
}
else {
for (i = 0; i < n; i++)
indexes[i] = (GLuint) s[i];
}
}
break;
case GL_HALF_FLOAT_ARB:
{
GLuint i;
const GLhalfARB *s = (const GLhalfARB *) src;
if (unpack->SwapBytes) {
for (i = 0; i < n; i++) {
GLhalfARB value = s[i];
SWAP2BYTE(value);
indexes[i] = (GLuint) _mesa_half_to_float(value);
}
}
else {
for (i = 0; i < n; i++)
indexes[i] = (GLuint) _mesa_half_to_float(s[i]);
}
}
break;
case GL_UNSIGNED_INT_24_8_EXT:
{
GLuint i;
const GLuint *s = (const GLuint *) src;
if (unpack->SwapBytes) {
for (i = 0; i < n; i++) {
GLuint value = s[i];
SWAP4BYTE(value);
indexes[i] = value & 0xff; /* lower 8 bits */
}
}
else {
for (i = 0; i < n; i++)
indexes[i] = s[i] & 0xff; /* lower 8 bits */
}
}
break;
case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
{
GLuint i;
const GLuint *s = (const GLuint *) src;
if (unpack->SwapBytes) {
for (i = 0; i < n; i++) {
GLuint value = s[i*2+1];
SWAP4BYTE(value);
indexes[i] = value & 0xff; /* lower 8 bits */
}
}
else {
for (i = 0; i < n; i++)
indexes[i] = s[i*2+1] & 0xff; /* lower 8 bits */
}
}
break;
default:
_mesa_problem(NULL, "bad srcType in extract_uint_indexes");
return;
}
}
/**
* Return source/dest RGBA indexes for unpacking pixels.
*/
static void
get_component_mapping(GLenum format,
GLint *rSrc,
GLint *gSrc,
GLint *bSrc,
GLint *aSrc,
GLint *rDst,
GLint *gDst,
GLint *bDst,
GLint *aDst)
{
switch (format) {
case GL_RED:
case GL_RED_INTEGER_EXT:
*rSrc = 0;
*gSrc = *bSrc = *aSrc = -1;
break;
case GL_GREEN:
case GL_GREEN_INTEGER_EXT:
*gSrc = 0;
*rSrc = *bSrc = *aSrc = -1;
break;
case GL_BLUE:
case GL_BLUE_INTEGER_EXT:
*bSrc = 0;
*rSrc = *gSrc = *aSrc = -1;
break;
case GL_ALPHA:
case GL_ALPHA_INTEGER_EXT:
*rSrc = *gSrc = *bSrc = -1;
*aSrc = 0;
break;
case GL_LUMINANCE:
case GL_LUMINANCE_INTEGER_EXT:
*rSrc = *gSrc = *bSrc = 0;
*aSrc = -1;
break;
case GL_LUMINANCE_ALPHA:
case GL_LUMINANCE_ALPHA_INTEGER_EXT:
*rSrc = *gSrc = *bSrc = 0;
*aSrc = 1;
break;
case GL_INTENSITY:
*rSrc = *gSrc = *bSrc = *aSrc = 0;
break;
case GL_RG:
case GL_RG_INTEGER:
*rSrc = 0;
*gSrc = 1;
*bSrc = -1;
*aSrc = -1;
*rDst = 0;
*gDst = 1;
*bDst = 2;
*aDst = 3;
break;
case GL_RGB:
case GL_RGB_INTEGER:
*rSrc = 0;
*gSrc = 1;
*bSrc = 2;
*aSrc = -1;
*rDst = 0;
*gDst = 1;
*bDst = 2;
*aDst = 3;
break;
case GL_BGR:
case GL_BGR_INTEGER:
*rSrc = 2;
*gSrc = 1;
*bSrc = 0;
*aSrc = -1;
*rDst = 2;
*gDst = 1;
*bDst = 0;
*aDst = 3;
break;
case GL_RGBA:
case GL_RGBA_INTEGER:
*rSrc = 0;
*gSrc = 1;
*bSrc = 2;
*aSrc = 3;
*rDst = 0;
*gDst = 1;
*bDst = 2;
*aDst = 3;
break;
case GL_BGRA:
case GL_BGRA_INTEGER:
*rSrc = 2;
*gSrc = 1;
*bSrc = 0;
*aSrc = 3;
*rDst = 2;
*gDst = 1;
*bDst = 0;
*aDst = 3;
break;
case GL_ABGR_EXT:
*rSrc = 3;
*gSrc = 2;
*bSrc = 1;
*aSrc = 0;
*rDst = 3;
*gDst = 2;
*bDst = 1;
*aDst = 0;
break;
case GL_DU8DV8_ATI:
case GL_DUDV_ATI:
*rSrc = 0;
*gSrc = 1;
*bSrc = -1;
*aSrc = -1;
break;
default:
_mesa_problem(NULL, "bad srcFormat %s in get_component_mapping",
_mesa_lookup_enum_by_nr(format));
return;
}
}
/*
* This function extracts floating point RGBA values from arbitrary
* image data. srcFormat and srcType are the format and type parameters
* passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
*
* Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
* implements the "Conversion to floating point", "Conversion to RGB",
* and "Final Expansion to RGBA" operations.
*
* Args: n - number of pixels
* rgba - output colors
* srcFormat - format of incoming data
* srcType - data type of incoming data
* src - source data pointer
* swapBytes - perform byteswapping of incoming data?
*/
static void
extract_float_rgba(GLuint n, GLfloat rgba[][4],
GLenum srcFormat, GLenum srcType, const GLvoid *src,
GLboolean swapBytes)
{
GLint rSrc, gSrc, bSrc, aSrc;
GLint stride;
GLint rDst, bDst, gDst, aDst;
GLboolean intFormat;
GLfloat rs = 1.0f, gs = 1.0f, bs = 1.0f, as = 1.0f; /* scale factors */
ASSERT(srcFormat == GL_RED ||
srcFormat == GL_GREEN ||
srcFormat == GL_BLUE ||
srcFormat == GL_ALPHA ||
srcFormat == GL_LUMINANCE ||
srcFormat == GL_LUMINANCE_ALPHA ||
srcFormat == GL_INTENSITY ||
srcFormat == GL_RG ||
srcFormat == GL_RGB ||
srcFormat == GL_BGR ||
srcFormat == GL_RGBA ||
srcFormat == GL_BGRA ||
srcFormat == GL_ABGR_EXT ||
srcFormat == GL_DU8DV8_ATI ||
srcFormat == GL_DUDV_ATI ||
srcFormat == GL_RED_INTEGER_EXT ||
srcFormat == GL_GREEN_INTEGER_EXT ||
srcFormat == GL_BLUE_INTEGER_EXT ||
srcFormat == GL_ALPHA_INTEGER_EXT ||
srcFormat == GL_RG_INTEGER ||
srcFormat == GL_RGB_INTEGER_EXT ||
srcFormat == GL_RGBA_INTEGER_EXT ||
srcFormat == GL_BGR_INTEGER_EXT ||
srcFormat == GL_BGRA_INTEGER_EXT ||
srcFormat == GL_LUMINANCE_INTEGER_EXT ||
srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
ASSERT(srcType == GL_UNSIGNED_BYTE ||
srcType == GL_BYTE ||
srcType == GL_UNSIGNED_SHORT ||
srcType == GL_SHORT ||
srcType == GL_UNSIGNED_INT ||
srcType == GL_INT ||
srcType == GL_HALF_FLOAT_ARB ||
srcType == GL_FLOAT ||
srcType == GL_UNSIGNED_BYTE_3_3_2 ||
srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
srcType == GL_UNSIGNED_SHORT_5_6_5 ||
srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
srcType == GL_UNSIGNED_INT_8_8_8_8 ||
srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
srcType == GL_UNSIGNED_INT_10_10_10_2 ||
srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
get_component_mapping(srcFormat,
&rSrc, &gSrc, &bSrc, &aSrc,
&rDst, &gDst, &bDst, &aDst);
stride = _mesa_components_in_format(srcFormat);
intFormat = _mesa_is_enum_format_integer(srcFormat);
#define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT_FLT, DEFAULT_INT, TYPE, CONVERSION) \
if ((SRC_INDEX) < 0) { \
GLuint i; \
if (intFormat) { \
for (i = 0; i < n; i++) { \
rgba[i][DST_INDEX] = DEFAULT_INT; \
} \
} \
else { \
for (i = 0; i < n; i++) { \
rgba[i][DST_INDEX] = DEFAULT_FLT; \
} \
} \
} \
else if (swapBytes) { \
const TYPE *s = (const TYPE *) src; \
GLuint i; \
for (i = 0; i < n; i++) { \
TYPE value = s[SRC_INDEX]; \
if (sizeof(TYPE) == 2) { \
SWAP2BYTE(value); \
} \
else if (sizeof(TYPE) == 4) { \
SWAP4BYTE(value); \
} \
if (intFormat) \
rgba[i][DST_INDEX] = (GLfloat) value; \
else \
rgba[i][DST_INDEX] = (GLfloat) CONVERSION(value); \
s += stride; \
} \
} \
else { \
const TYPE *s = (const TYPE *) src; \
GLuint i; \
if (intFormat) { \
for (i = 0; i < n; i++) { \
rgba[i][DST_INDEX] = (GLfloat) s[SRC_INDEX]; \
s += stride; \
} \
} \
else { \
for (i = 0; i < n; i++) { \
rgba[i][DST_INDEX] = (GLfloat) CONVERSION(s[SRC_INDEX]); \
s += stride; \
} \
} \
}
switch (srcType) {
case GL_UNSIGNED_BYTE:
PROCESS(rSrc, RCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
PROCESS(gSrc, GCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
PROCESS(bSrc, BCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
PROCESS(aSrc, ACOMP, 1.0F, 255, GLubyte, UBYTE_TO_FLOAT);
break;
case GL_BYTE:
PROCESS(rSrc, RCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ);
PROCESS(gSrc, GCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ);
PROCESS(bSrc, BCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ);
PROCESS(aSrc, ACOMP, 1.0F, 127, GLbyte, BYTE_TO_FLOATZ);
break;
case GL_UNSIGNED_SHORT:
PROCESS(rSrc, RCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
PROCESS(gSrc, GCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
PROCESS(bSrc, BCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
PROCESS(aSrc, ACOMP, 1.0F, 0xffff, GLushort, USHORT_TO_FLOAT);
break;
case GL_SHORT:
PROCESS(rSrc, RCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ);
PROCESS(gSrc, GCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ);
PROCESS(bSrc, BCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ);
PROCESS(aSrc, ACOMP, 1.0F, 32767, GLshort, SHORT_TO_FLOATZ);
break;
case GL_UNSIGNED_INT:
PROCESS(rSrc, RCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
PROCESS(gSrc, GCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
PROCESS(bSrc, BCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
PROCESS(aSrc, ACOMP, 1.0F, 0xffffffff, GLuint, UINT_TO_FLOAT);
break;
case GL_INT:
PROCESS(rSrc, RCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
PROCESS(gSrc, GCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
PROCESS(bSrc, BCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
PROCESS(aSrc, ACOMP, 1.0F, 2147483647, GLint, INT_TO_FLOAT);
break;
case GL_FLOAT:
PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLfloat, (GLfloat));
break;
case GL_HALF_FLOAT_ARB:
PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLhalfARB, _mesa_half_to_float);
break;
case GL_UNSIGNED_BYTE_3_3_2:
{
const GLubyte *ubsrc = (const GLubyte *) src;
GLuint i;
if (!intFormat) {
rs = 1.0F / 7.0F;
gs = 1.0F / 7.0F;
bs = 1.0F / 3.0F;
}
for (i = 0; i < n; i ++) {
GLubyte p = ubsrc[i];
rgba[i][rDst] = ((p >> 5) ) * rs;
rgba[i][gDst] = ((p >> 2) & 0x7) * gs;
rgba[i][bDst] = ((p ) & 0x3) * bs;
rgba[i][aDst] = 1.0F;
}
}
break;
case GL_UNSIGNED_BYTE_2_3_3_REV:
{
const GLubyte *ubsrc = (const GLubyte *) src;
GLuint i;
if (!intFormat) {
rs = 1.0F / 7.0F;
gs = 1.0F / 7.0F;
bs = 1.0F / 3.0F;
}
for (i = 0; i < n; i ++) {
GLubyte p = ubsrc[i];
rgba[i][rDst] = ((p ) & 0x7) * rs;
rgba[i][gDst] = ((p >> 3) & 0x7) * gs;
rgba[i][bDst] = ((p >> 6) ) * bs;
rgba[i][aDst] = 1.0F;
}
}
break;
case GL_UNSIGNED_SHORT_5_6_5:
if (!intFormat) {
rs = 1.0F / 31.0F;
gs = 1.0F / 63.0F;
bs = 1.0F / 31.0F;
}
if (swapBytes) {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
SWAP2BYTE(p);
rgba[i][rDst] = ((p >> 11) ) * rs;
rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
rgba[i][bDst] = ((p ) & 0x1f) * bs;
rgba[i][aDst] = 1.0F;
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rDst] = ((p >> 11) ) * rs;
rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
rgba[i][bDst] = ((p ) & 0x1f) * bs;
rgba[i][aDst] = 1.0F;
}
}
break;
case GL_UNSIGNED_SHORT_5_6_5_REV:
if (!intFormat) {
rs = 1.0F / 31.0F;
gs = 1.0F / 63.0F;
bs = 1.0F / 31.0F;
}
if (swapBytes) {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
SWAP2BYTE(p);
rgba[i][rDst] = ((p ) & 0x1f) * rs;
rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
rgba[i][bDst] = ((p >> 11) ) * bs;
rgba[i][aDst] = 1.0F;
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rDst] = ((p ) & 0x1f) * rs;
rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
rgba[i][bDst] = ((p >> 11) ) * bs;
rgba[i][aDst] = 1.0F;
}
}
break;
case GL_UNSIGNED_SHORT_4_4_4_4:
if (!intFormat) {
rs = gs = bs = as = 1.0F / 15.0F;
}
if (swapBytes) {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
SWAP2BYTE(p);
rgba[i][rDst] = ((p >> 12) ) * rs;
rgba[i][gDst] = ((p >> 8) & 0xf) * gs;
rgba[i][bDst] = ((p >> 4) & 0xf) * bs;
rgba[i][aDst] = ((p ) & 0xf) * as;
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rDst] = ((p >> 12) ) * rs;
rgba[i][gDst] = ((p >> 8) & 0xf) * gs;
rgba[i][bDst] = ((p >> 4) & 0xf) * bs;
rgba[i][aDst] = ((p ) & 0xf) * as;
}
}
break;
case GL_UNSIGNED_SHORT_4_4_4_4_REV:
if (!intFormat) {
rs = gs = bs = as = 1.0F / 15.0F;
}
if (swapBytes) {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
SWAP2BYTE(p);
rgba[i][rDst] = ((p ) & 0xf) * rs;
rgba[i][gDst] = ((p >> 4) & 0xf) * gs;
rgba[i][bDst] = ((p >> 8) & 0xf) * bs;
rgba[i][aDst] = ((p >> 12) ) * as;
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rDst] = ((p ) & 0xf) * rs;
rgba[i][gDst] = ((p >> 4) & 0xf) * gs;
rgba[i][bDst] = ((p >> 8) & 0xf) * bs;
rgba[i][aDst] = ((p >> 12) ) * as;
}
}
break;
case GL_UNSIGNED_SHORT_5_5_5_1:
if (!intFormat) {
rs = gs = bs = 1.0F / 31.0F;
}
if (swapBytes) {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
SWAP2BYTE(p);
rgba[i][rDst] = ((p >> 11) ) * rs;
rgba[i][gDst] = ((p >> 6) & 0x1f) * gs;
rgba[i][bDst] = ((p >> 1) & 0x1f) * bs;
rgba[i][aDst] = ((p ) & 0x1) * as;
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rDst] = ((p >> 11) ) * rs;
rgba[i][gDst] = ((p >> 6) & 0x1f) * gs;
rgba[i][bDst] = ((p >> 1) & 0x1f) * bs;
rgba[i][aDst] = ((p ) & 0x1) * as;
}
}
break;
case GL_UNSIGNED_SHORT_1_5_5_5_REV:
if (!intFormat) {
rs = gs = bs = 1.0F / 31.0F;
}
if (swapBytes) {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
SWAP2BYTE(p);
rgba[i][rDst] = ((p ) & 0x1f) * rs;
rgba[i][gDst] = ((p >> 5) & 0x1f) * gs;
rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
rgba[i][aDst] = ((p >> 15) ) * as;
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rDst] = ((p ) & 0x1f) * rs;
rgba[i][gDst] = ((p >> 5) & 0x1f) * gs;
rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
rgba[i][aDst] = ((p >> 15) ) * as;
}
}
break;
case GL_UNSIGNED_INT_8_8_8_8:
if (swapBytes) {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
if (intFormat) {
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = (GLfloat) ((p ) & 0xff);
rgba[i][gDst] = (GLfloat) ((p >> 8) & 0xff);
rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
rgba[i][aDst] = (GLfloat) ((p >> 24) );
}
}
else {
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = UBYTE_TO_FLOAT((p ) & 0xff);
rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24) );
}
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
if (intFormat) {
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = (GLfloat) ((p >> 24) );
rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
rgba[i][bDst] = (GLfloat) ((p >> 8) & 0xff);
rgba[i][aDst] = (GLfloat) ((p ) & 0xff);
}
}
else {
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24) );
rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
rgba[i][aDst] = UBYTE_TO_FLOAT((p ) & 0xff);
}
}
}
break;
case GL_UNSIGNED_INT_8_8_8_8_REV:
if (swapBytes) {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
if (intFormat) {
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = (GLfloat) ((p >> 24) );
rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
rgba[i][bDst] = (GLfloat) ((p >> 8) & 0xff);
rgba[i][aDst] = (GLfloat) ((p ) & 0xff);
}
}
else {
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24) );
rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
rgba[i][aDst] = UBYTE_TO_FLOAT((p ) & 0xff);
}
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
if (intFormat) {
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = (GLfloat) ((p ) & 0xff);
rgba[i][gDst] = (GLfloat) ((p >> 8) & 0xff);
rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
rgba[i][aDst] = (GLfloat) ((p >> 24) );
}
}
else {
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = UBYTE_TO_FLOAT((p ) & 0xff);
rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24) );
}
}
}
break;
case GL_UNSIGNED_INT_10_10_10_2:
if (!intFormat) {
rs = 1.0F / 1023.0F;
gs = 1.0F / 1023.0F;
bs = 1.0F / 1023.0F;
as = 1.0F / 3.0F;
}
if (swapBytes) {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
SWAP4BYTE(p);
rgba[i][rDst] = ((p >> 22) ) * rs;
rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
rgba[i][bDst] = ((p >> 2) & 0x3ff) * bs;
rgba[i][aDst] = ((p ) & 0x3 ) * as;
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = ((p >> 22) ) * rs;
rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
rgba[i][bDst] = ((p >> 2) & 0x3ff) * bs;
rgba[i][aDst] = ((p ) & 0x3 ) * as;
}
}
break;
case GL_UNSIGNED_INT_2_10_10_10_REV:
if (!intFormat) {
rs = 1.0F / 1023.0F;
gs = 1.0F / 1023.0F;
bs = 1.0F / 1023.0F;
as = 1.0F / 3.0F;
}
if (swapBytes) {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
SWAP4BYTE(p);
rgba[i][rDst] = ((p ) & 0x3ff) * rs;
rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
rgba[i][aDst] = ((p >> 30) ) * as;
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = ((p ) & 0x3ff) * rs;
rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
rgba[i][aDst] = ((p >> 30) ) * as;
}
}
break;
case GL_UNSIGNED_INT_5_9_9_9_REV:
if (swapBytes) {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
GLfloat f[3];
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
SWAP4BYTE(p);
rgb9e5_to_float3(p, f);
rgba[i][rDst] = f[0];
rgba[i][gDst] = f[1];
rgba[i][bDst] = f[2];
rgba[i][aDst] = 1.0F;
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
GLfloat f[3];
for (i = 0; i < n; i ++) {
rgb9e5_to_float3(uisrc[i], f);
rgba[i][rDst] = f[0];
rgba[i][gDst] = f[1];
rgba[i][bDst] = f[2];
rgba[i][aDst] = 1.0F;
}
}
break;
case GL_UNSIGNED_INT_10F_11F_11F_REV:
if (swapBytes) {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
GLfloat f[3];
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
SWAP4BYTE(p);
r11g11b10f_to_float3(p, f);
rgba[i][rDst] = f[0];
rgba[i][gDst] = f[1];
rgba[i][bDst] = f[2];
rgba[i][aDst] = 1.0F;
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
GLfloat f[3];
for (i = 0; i < n; i ++) {
r11g11b10f_to_float3(uisrc[i], f);
rgba[i][rDst] = f[0];
rgba[i][gDst] = f[1];
rgba[i][bDst] = f[2];
rgba[i][aDst] = 1.0F;
}
}
break;
default:
_mesa_problem(NULL, "bad srcType in extract float data");
break;
}
#undef PROCESS
}
static inline GLuint
clamp_float_to_uint(GLfloat f)
{
return f < 0.0F ? 0 : F_TO_I(f);
}
static inline GLuint
clamp_half_to_uint(GLhalfARB h)
{
GLfloat f = _mesa_half_to_float(h);
return f < 0.0F ? 0 : F_TO_I(f);
}
/**
* \sa extract_float_rgba()
*/
static void
extract_uint_rgba(GLuint n, GLuint rgba[][4],
GLenum srcFormat, GLenum srcType, const GLvoid *src,
GLboolean swapBytes)
{
GLint rSrc, gSrc, bSrc, aSrc;
GLint stride;
GLint rDst, bDst, gDst, aDst;
ASSERT(srcFormat == GL_RED ||
srcFormat == GL_GREEN ||
srcFormat == GL_BLUE ||
srcFormat == GL_ALPHA ||
srcFormat == GL_LUMINANCE ||
srcFormat == GL_LUMINANCE_ALPHA ||
srcFormat == GL_INTENSITY ||
srcFormat == GL_RG ||
srcFormat == GL_RGB ||
srcFormat == GL_BGR ||
srcFormat == GL_RGBA ||
srcFormat == GL_BGRA ||
srcFormat == GL_ABGR_EXT ||
srcFormat == GL_DU8DV8_ATI ||
srcFormat == GL_DUDV_ATI ||
srcFormat == GL_RED_INTEGER_EXT ||
srcFormat == GL_RG_INTEGER ||
srcFormat == GL_GREEN_INTEGER_EXT ||
srcFormat == GL_BLUE_INTEGER_EXT ||
srcFormat == GL_ALPHA_INTEGER_EXT ||
srcFormat == GL_RGB_INTEGER_EXT ||
srcFormat == GL_RGBA_INTEGER_EXT ||
srcFormat == GL_BGR_INTEGER_EXT ||
srcFormat == GL_BGRA_INTEGER_EXT ||
srcFormat == GL_LUMINANCE_INTEGER_EXT ||
srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
ASSERT(srcType == GL_UNSIGNED_BYTE ||
srcType == GL_BYTE ||
srcType == GL_UNSIGNED_SHORT ||
srcType == GL_SHORT ||
srcType == GL_UNSIGNED_INT ||
srcType == GL_INT ||
srcType == GL_HALF_FLOAT_ARB ||
srcType == GL_FLOAT ||
srcType == GL_UNSIGNED_BYTE_3_3_2 ||
srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
srcType == GL_UNSIGNED_SHORT_5_6_5 ||
srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
srcType == GL_UNSIGNED_INT_8_8_8_8 ||
srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
srcType == GL_UNSIGNED_INT_10_10_10_2 ||
srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
get_component_mapping(srcFormat,
&rSrc, &gSrc, &bSrc, &aSrc,
&rDst, &gDst, &bDst, &aDst);
stride = _mesa_components_in_format(srcFormat);
#define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT, TYPE, CONVERSION) \
if ((SRC_INDEX) < 0) { \
GLuint i; \
for (i = 0; i < n; i++) { \
rgba[i][DST_INDEX] = DEFAULT; \
} \
} \
else if (swapBytes) { \
const TYPE *s = (const TYPE *) src; \
GLuint i; \
for (i = 0; i < n; i++) { \
TYPE value = s[SRC_INDEX]; \
if (sizeof(TYPE) == 2) { \
SWAP2BYTE(value); \
} \
else if (sizeof(TYPE) == 4) { \
SWAP4BYTE(value); \
} \
rgba[i][DST_INDEX] = CONVERSION(value); \
s += stride; \
} \
} \
else { \
const TYPE *s = (const TYPE *) src; \
GLuint i; \
for (i = 0; i < n; i++) { \
rgba[i][DST_INDEX] = CONVERSION(s[SRC_INDEX]); \
s += stride; \
} \
}
switch (srcType) {
case GL_UNSIGNED_BYTE:
PROCESS(rSrc, RCOMP, 0, GLubyte, (GLuint));
PROCESS(gSrc, GCOMP, 0, GLubyte, (GLuint));
PROCESS(bSrc, BCOMP, 0, GLubyte, (GLuint));
PROCESS(aSrc, ACOMP, 1, GLubyte, (GLuint));
break;
case GL_BYTE:
PROCESS(rSrc, RCOMP, 0, GLbyte, (GLuint));
PROCESS(gSrc, GCOMP, 0, GLbyte, (GLuint));
PROCESS(bSrc, BCOMP, 0, GLbyte, (GLuint));
PROCESS(aSrc, ACOMP, 1, GLbyte, (GLuint));
break;
case GL_UNSIGNED_SHORT:
PROCESS(rSrc, RCOMP, 0, GLushort, (GLuint));
PROCESS(gSrc, GCOMP, 0, GLushort, (GLuint));
PROCESS(bSrc, BCOMP, 0, GLushort, (GLuint));
PROCESS(aSrc, ACOMP, 1, GLushort, (GLuint));
break;
case GL_SHORT:
PROCESS(rSrc, RCOMP, 0, GLshort, (GLuint));
PROCESS(gSrc, GCOMP, 0, GLshort, (GLuint));
PROCESS(bSrc, BCOMP, 0, GLshort, (GLuint));
PROCESS(aSrc, ACOMP, 1, GLshort, (GLuint));
break;
case GL_UNSIGNED_INT:
PROCESS(rSrc, RCOMP, 0, GLuint, (GLuint));
PROCESS(gSrc, GCOMP, 0, GLuint, (GLuint));
PROCESS(bSrc, BCOMP, 0, GLuint, (GLuint));
PROCESS(aSrc, ACOMP, 1, GLuint, (GLuint));
break;
case GL_INT:
PROCESS(rSrc, RCOMP, 0, GLint, (GLuint));
PROCESS(gSrc, GCOMP, 0, GLint, (GLuint));
PROCESS(bSrc, BCOMP, 0, GLint, (GLuint));
PROCESS(aSrc, ACOMP, 1, GLint, (GLuint));
break;
case GL_FLOAT:
PROCESS(rSrc, RCOMP, 0, GLfloat, clamp_float_to_uint);
PROCESS(gSrc, GCOMP, 0, GLfloat, clamp_float_to_uint);
PROCESS(bSrc, BCOMP, 0, GLfloat, clamp_float_to_uint);
PROCESS(aSrc, ACOMP, 1, GLfloat, clamp_float_to_uint);
break;
case GL_HALF_FLOAT_ARB:
PROCESS(rSrc, RCOMP, 0, GLhalfARB, clamp_half_to_uint);
PROCESS(gSrc, GCOMP, 0, GLhalfARB, clamp_half_to_uint);
PROCESS(bSrc, BCOMP, 0, GLhalfARB, clamp_half_to_uint);
PROCESS(aSrc, ACOMP, 1, GLhalfARB, clamp_half_to_uint);
break;
case GL_UNSIGNED_BYTE_3_3_2:
{
const GLubyte *ubsrc = (const GLubyte *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLubyte p = ubsrc[i];
rgba[i][rDst] = ((p >> 5) );
rgba[i][gDst] = ((p >> 2) & 0x7);
rgba[i][bDst] = ((p ) & 0x3);
rgba[i][aDst] = 1;
}
}
break;
case GL_UNSIGNED_BYTE_2_3_3_REV:
{
const GLubyte *ubsrc = (const GLubyte *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLubyte p = ubsrc[i];
rgba[i][rDst] = ((p ) & 0x7);
rgba[i][gDst] = ((p >> 3) & 0x7);
rgba[i][bDst] = ((p >> 6) );
rgba[i][aDst] = 1;
}
}
break;
case GL_UNSIGNED_SHORT_5_6_5:
if (swapBytes) {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
SWAP2BYTE(p);
rgba[i][rDst] = ((p >> 11) );
rgba[i][gDst] = ((p >> 5) & 0x3f);
rgba[i][bDst] = ((p ) & 0x1f);
rgba[i][aDst] = 1;
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rDst] = ((p >> 11) );
rgba[i][gDst] = ((p >> 5) & 0x3f);
rgba[i][bDst] = ((p ) & 0x1f);
rgba[i][aDst] = 1;
}
}
break;
case GL_UNSIGNED_SHORT_5_6_5_REV:
if (swapBytes) {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
SWAP2BYTE(p);
rgba[i][rDst] = ((p ) & 0x1f);
rgba[i][gDst] = ((p >> 5) & 0x3f);
rgba[i][bDst] = ((p >> 11) );
rgba[i][aDst] = 1;
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rDst] = ((p ) & 0x1f);
rgba[i][gDst] = ((p >> 5) & 0x3f);
rgba[i][bDst] = ((p >> 11) );
rgba[i][aDst] = 1;
}
}
break;
case GL_UNSIGNED_SHORT_4_4_4_4:
if (swapBytes) {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
SWAP2BYTE(p);
rgba[i][rDst] = ((p >> 12) );
rgba[i][gDst] = ((p >> 8) & 0xf);
rgba[i][bDst] = ((p >> 4) & 0xf);
rgba[i][aDst] = ((p ) & 0xf);
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rDst] = ((p >> 12) );
rgba[i][gDst] = ((p >> 8) & 0xf);
rgba[i][bDst] = ((p >> 4) & 0xf);
rgba[i][aDst] = ((p ) & 0xf);
}
}
break;
case GL_UNSIGNED_SHORT_4_4_4_4_REV:
if (swapBytes) {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
SWAP2BYTE(p);
rgba[i][rDst] = ((p ) & 0xf);
rgba[i][gDst] = ((p >> 4) & 0xf);
rgba[i][bDst] = ((p >> 8) & 0xf);
rgba[i][aDst] = ((p >> 12) );
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rDst] = ((p ) & 0xf);
rgba[i][gDst] = ((p >> 4) & 0xf);
rgba[i][bDst] = ((p >> 8) & 0xf);
rgba[i][aDst] = ((p >> 12) );
}
}
break;
case GL_UNSIGNED_SHORT_5_5_5_1:
if (swapBytes) {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
SWAP2BYTE(p);
rgba[i][rDst] = ((p >> 11) );
rgba[i][gDst] = ((p >> 6) & 0x1f);
rgba[i][bDst] = ((p >> 1) & 0x1f);
rgba[i][aDst] = ((p ) & 0x1 );
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rDst] = ((p >> 11) );
rgba[i][gDst] = ((p >> 6) & 0x1f);
rgba[i][bDst] = ((p >> 1) & 0x1f);
rgba[i][aDst] = ((p ) & 0x1 );
}
}
break;
case GL_UNSIGNED_SHORT_1_5_5_5_REV:
if (swapBytes) {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
SWAP2BYTE(p);
rgba[i][rDst] = ((p ) & 0x1f);
rgba[i][gDst] = ((p >> 5) & 0x1f);
rgba[i][bDst] = ((p >> 10) & 0x1f);
rgba[i][aDst] = ((p >> 15) );
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rDst] = ((p ) & 0x1f);
rgba[i][gDst] = ((p >> 5) & 0x1f);
rgba[i][bDst] = ((p >> 10) & 0x1f);
rgba[i][aDst] = ((p >> 15) );
}
}
break;
case GL_UNSIGNED_INT_8_8_8_8:
if (swapBytes) {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = ((p ) & 0xff);
rgba[i][gDst] = ((p >> 8) & 0xff);
rgba[i][bDst] = ((p >> 16) & 0xff);
rgba[i][aDst] = ((p >> 24) );
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = ((p >> 24) );
rgba[i][gDst] = ((p >> 16) & 0xff);
rgba[i][bDst] = ((p >> 8) & 0xff);
rgba[i][aDst] = ((p ) & 0xff);
}
}
break;
case GL_UNSIGNED_INT_8_8_8_8_REV:
if (swapBytes) {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = ((p >> 24) );
rgba[i][gDst] = ((p >> 16) & 0xff);
rgba[i][bDst] = ((p >> 8) & 0xff);
rgba[i][aDst] = ((p ) & 0xff);
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = ((p ) & 0xff);
rgba[i][gDst] = ((p >> 8) & 0xff);
rgba[i][bDst] = ((p >> 16) & 0xff);
rgba[i][aDst] = ((p >> 24) );
}
}
break;
case GL_UNSIGNED_INT_10_10_10_2:
if (swapBytes) {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
SWAP4BYTE(p);
rgba[i][rDst] = ((p >> 22) );
rgba[i][gDst] = ((p >> 12) & 0x3ff);
rgba[i][bDst] = ((p >> 2) & 0x3ff);
rgba[i][aDst] = ((p ) & 0x3 );
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = ((p >> 22) );
rgba[i][gDst] = ((p >> 12) & 0x3ff);
rgba[i][bDst] = ((p >> 2) & 0x3ff);
rgba[i][aDst] = ((p ) & 0x3 );
}
}
break;
case GL_UNSIGNED_INT_2_10_10_10_REV:
if (swapBytes) {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
SWAP4BYTE(p);
rgba[i][rDst] = ((p ) & 0x3ff);
rgba[i][gDst] = ((p >> 10) & 0x3ff);
rgba[i][bDst] = ((p >> 20) & 0x3ff);
rgba[i][aDst] = ((p >> 30) );
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rDst] = ((p ) & 0x3ff);
rgba[i][gDst] = ((p >> 10) & 0x3ff);
rgba[i][bDst] = ((p >> 20) & 0x3ff);
rgba[i][aDst] = ((p >> 30) );
}
}
break;
case GL_UNSIGNED_INT_5_9_9_9_REV:
if (swapBytes) {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
float f[3];
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
SWAP4BYTE(p);
rgb9e5_to_float3(p, f);
rgba[i][rDst] = clamp_float_to_uint(f[0]);
rgba[i][gDst] = clamp_float_to_uint(f[1]);
rgba[i][bDst] = clamp_float_to_uint(f[2]);
rgba[i][aDst] = 1;
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
float f[3];
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgb9e5_to_float3(p, f);
rgba[i][rDst] = clamp_float_to_uint(f[0]);
rgba[i][gDst] = clamp_float_to_uint(f[1]);
rgba[i][bDst] = clamp_float_to_uint(f[2]);
rgba[i][aDst] = 1;
}
}
break;
case GL_UNSIGNED_INT_10F_11F_11F_REV:
if (swapBytes) {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
float f[3];
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
SWAP4BYTE(p);
r11g11b10f_to_float3(p, f);
rgba[i][rDst] = clamp_float_to_uint(f[0]);
rgba[i][gDst] = clamp_float_to_uint(f[1]);
rgba[i][bDst] = clamp_float_to_uint(f[2]);
rgba[i][aDst] = 1;
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
float f[3];
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
r11g11b10f_to_float3(p, f);
rgba[i][rDst] = clamp_float_to_uint(f[0]);
rgba[i][gDst] = clamp_float_to_uint(f[1]);
rgba[i][bDst] = clamp_float_to_uint(f[2]);
rgba[i][aDst] = 1;
}
}
break;
default:
_mesa_problem(NULL, "bad srcType in extract uint data");
break;
}
#undef PROCESS
}
/*
* Unpack a row of color image data from a client buffer according to
* the pixel unpacking parameters.
* Return GLubyte values in the specified dest image format.
* This is used by glDrawPixels and glTexImage?D().
* \param ctx - the context
* n - number of pixels in the span
* dstFormat - format of destination color array
* dest - the destination color array
* srcFormat - source image format
* srcType - source image data type
* source - source image pointer
* srcPacking - pixel unpacking parameters
* transferOps - bitmask of IMAGE_*_BIT values of operations to apply
*
* XXX perhaps expand this to process whole images someday.
*/
void
_mesa_unpack_color_span_ubyte(struct gl_context *ctx,
GLuint n, GLenum dstFormat, GLubyte dest[],
GLenum srcFormat, GLenum srcType,
const GLvoid *source,
const struct gl_pixelstore_attrib *srcPacking,
GLbitfield transferOps )
{
GLboolean intFormat = _mesa_is_enum_format_integer(srcFormat);
ASSERT(dstFormat == GL_ALPHA ||
dstFormat == GL_LUMINANCE ||
dstFormat == GL_LUMINANCE_ALPHA ||
dstFormat == GL_INTENSITY ||
dstFormat == GL_RED ||
dstFormat == GL_RG ||
dstFormat == GL_RGB ||
dstFormat == GL_RGBA);
ASSERT(srcFormat == GL_RED ||
srcFormat == GL_GREEN ||
srcFormat == GL_BLUE ||
srcFormat == GL_ALPHA ||
srcFormat == GL_LUMINANCE ||
srcFormat == GL_LUMINANCE_ALPHA ||
srcFormat == GL_INTENSITY ||
srcFormat == GL_RG ||
srcFormat == GL_RGB ||
srcFormat == GL_BGR ||
srcFormat == GL_RGBA ||
srcFormat == GL_BGRA ||
srcFormat == GL_ABGR_EXT ||
srcFormat == GL_COLOR_INDEX);
ASSERT(srcType == GL_BITMAP ||
srcType == GL_UNSIGNED_BYTE ||
srcType == GL_BYTE ||
srcType == GL_UNSIGNED_SHORT ||
srcType == GL_SHORT ||
srcType == GL_UNSIGNED_INT ||
srcType == GL_INT ||
srcType == GL_HALF_FLOAT_ARB ||
srcType == GL_FLOAT ||
srcType == GL_UNSIGNED_BYTE_3_3_2 ||
srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
srcType == GL_UNSIGNED_SHORT_5_6_5 ||
srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
srcType == GL_UNSIGNED_INT_8_8_8_8 ||
srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
srcType == GL_UNSIGNED_INT_10_10_10_2 ||
srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
/* EXT_texture_integer specifies no transfer ops on integer
* types in the resolved issues section. Just set them to 0
* for integer surfaces.
*/
if (intFormat)
transferOps = 0;
/* Try simple cases first */
if (transferOps == 0) {
if (srcType == GL_UNSIGNED_BYTE) {
if (dstFormat == GL_RGBA) {
if (srcFormat == GL_RGBA) {
memcpy( dest, source, n * 4 * sizeof(GLubyte) );
return;
}
else if (srcFormat == GL_RGB) {
GLuint i;
const GLubyte *src = (const GLubyte *) source;
GLubyte *dst = dest;
for (i = 0; i < n; i++) {
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = 255;
src += 3;
dst += 4;
}
return;
}
}
else if (dstFormat == GL_RGB) {
if (srcFormat == GL_RGB) {
memcpy( dest, source, n * 3 * sizeof(GLubyte) );
return;
}
else if (srcFormat == GL_RGBA) {
GLuint i;
const GLubyte *src = (const GLubyte *) source;
GLubyte *dst = dest;
for (i = 0; i < n; i++) {
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
src += 4;
dst += 3;
}
return;
}
}
else if (dstFormat == srcFormat) {
GLint comps = _mesa_components_in_format(srcFormat);
assert(comps > 0);
memcpy( dest, source, n * comps * sizeof(GLubyte) );
return;
}
}
}
/* general solution begins here */
{
GLint dstComponents;
GLint rDst, gDst, bDst, aDst, lDst, iDst;
GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
if (!rgba) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
return;
}
dstComponents = _mesa_components_in_format( dstFormat );
/* source & dest image formats should have been error checked by now */
assert(dstComponents > 0);
/*
* Extract image data and convert to RGBA floats
*/
if (srcFormat == GL_COLOR_INDEX) {
GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
if (!indexes) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
free(rgba);
return;
}
extract_uint_indexes(n, indexes, srcFormat, srcType, source,
srcPacking);
/* Convert indexes to RGBA */
if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
_mesa_shift_and_offset_ci(ctx, n, indexes);
}
_mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
/* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
* with color indexes.
*/
transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
free(indexes);
}
else {
/* non-color index data */
extract_float_rgba(n, rgba, srcFormat, srcType, source,
srcPacking->SwapBytes);
}
/* Need to clamp if returning GLubytes */
transferOps |= IMAGE_CLAMP_BIT;
if (transferOps) {
_mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
}
get_component_indexes(dstFormat,
&rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
/* Now return the GLubyte data in the requested dstFormat */
if (rDst >= 0) {
GLubyte *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
CLAMPED_FLOAT_TO_UBYTE(dst[rDst], rgba[i][RCOMP]);
dst += dstComponents;
}
}
if (gDst >= 0) {
GLubyte *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
CLAMPED_FLOAT_TO_UBYTE(dst[gDst], rgba[i][GCOMP]);
dst += dstComponents;
}
}
if (bDst >= 0) {
GLubyte *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
CLAMPED_FLOAT_TO_UBYTE(dst[bDst], rgba[i][BCOMP]);
dst += dstComponents;
}
}
if (aDst >= 0) {
GLubyte *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
CLAMPED_FLOAT_TO_UBYTE(dst[aDst], rgba[i][ACOMP]);
dst += dstComponents;
}
}
if (iDst >= 0) {
GLubyte *dst = dest;
GLuint i;
assert(iDst == 0);
assert(dstComponents == 1);
for (i = 0; i < n; i++) {
/* Intensity comes from red channel */
CLAMPED_FLOAT_TO_UBYTE(dst[i], rgba[i][RCOMP]);
}
}
if (lDst >= 0) {
GLubyte *dst = dest;
GLuint i;
assert(lDst == 0);
for (i = 0; i < n; i++) {
/* Luminance comes from red channel */
CLAMPED_FLOAT_TO_UBYTE(dst[0], rgba[i][RCOMP]);
dst += dstComponents;
}
}
free(rgba);
}
}
/**
* Same as _mesa_unpack_color_span_ubyte(), but return GLfloat data
* instead of GLubyte.
*/
void
_mesa_unpack_color_span_float( struct gl_context *ctx,
GLuint n, GLenum dstFormat, GLfloat dest[],
GLenum srcFormat, GLenum srcType,
const GLvoid *source,
const struct gl_pixelstore_attrib *srcPacking,
GLbitfield transferOps )
{
ASSERT(dstFormat == GL_ALPHA ||
dstFormat == GL_LUMINANCE ||
dstFormat == GL_LUMINANCE_ALPHA ||
dstFormat == GL_INTENSITY ||
dstFormat == GL_RED ||
dstFormat == GL_RG ||
dstFormat == GL_RGB ||
dstFormat == GL_RGBA);
ASSERT(srcFormat == GL_RED ||
srcFormat == GL_GREEN ||
srcFormat == GL_BLUE ||
srcFormat == GL_ALPHA ||
srcFormat == GL_LUMINANCE ||
srcFormat == GL_LUMINANCE_ALPHA ||
srcFormat == GL_INTENSITY ||
srcFormat == GL_RG ||
srcFormat == GL_RGB ||
srcFormat == GL_BGR ||
srcFormat == GL_RGBA ||
srcFormat == GL_BGRA ||
srcFormat == GL_ABGR_EXT ||
srcFormat == GL_RED_INTEGER_EXT ||
srcFormat == GL_GREEN_INTEGER_EXT ||
srcFormat == GL_BLUE_INTEGER_EXT ||
srcFormat == GL_ALPHA_INTEGER_EXT ||
srcFormat == GL_RG_INTEGER ||
srcFormat == GL_RGB_INTEGER_EXT ||
srcFormat == GL_RGBA_INTEGER_EXT ||
srcFormat == GL_BGR_INTEGER_EXT ||
srcFormat == GL_BGRA_INTEGER_EXT ||
srcFormat == GL_LUMINANCE_INTEGER_EXT ||
srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT ||
srcFormat == GL_COLOR_INDEX);
ASSERT(srcType == GL_BITMAP ||
srcType == GL_UNSIGNED_BYTE ||
srcType == GL_BYTE ||
srcType == GL_UNSIGNED_SHORT ||
srcType == GL_SHORT ||
srcType == GL_UNSIGNED_INT ||
srcType == GL_INT ||
srcType == GL_HALF_FLOAT_ARB ||
srcType == GL_FLOAT ||
srcType == GL_UNSIGNED_BYTE_3_3_2 ||
srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
srcType == GL_UNSIGNED_SHORT_5_6_5 ||
srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
srcType == GL_UNSIGNED_INT_8_8_8_8 ||
srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
srcType == GL_UNSIGNED_INT_10_10_10_2 ||
srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
/* general solution, no special cases, yet */
{
GLint dstComponents;
GLint rDst, gDst, bDst, aDst, lDst, iDst;
GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
GLboolean intFormat = _mesa_is_enum_format_integer(srcFormat);
if (!rgba) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
return;
}
dstComponents = _mesa_components_in_format( dstFormat );
/* source & dest image formats should have been error checked by now */
assert(dstComponents > 0);
/* EXT_texture_integer specifies no transfer ops on integer
* types in the resolved issues section. Just set them to 0
* for integer surfaces.
*/
if (intFormat)
transferOps = 0;
/*
* Extract image data and convert to RGBA floats
*/
if (srcFormat == GL_COLOR_INDEX) {
GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
if (!indexes) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
free(rgba);
return;
}
extract_uint_indexes(n, indexes, srcFormat, srcType, source,
srcPacking);
/* Convert indexes to RGBA */
if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
_mesa_shift_and_offset_ci(ctx, n, indexes);
}
_mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
/* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
* with color indexes.
*/
transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
free(indexes);
}
else {
/* non-color index data */
extract_float_rgba(n, rgba, srcFormat, srcType, source,
srcPacking->SwapBytes);
}
if (transferOps) {
_mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
}
get_component_indexes(dstFormat,
&rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
/* Now pack results in the requested dstFormat */
if (rDst >= 0) {
GLfloat *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[rDst] = rgba[i][RCOMP];
dst += dstComponents;
}
}
if (gDst >= 0) {
GLfloat *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[gDst] = rgba[i][GCOMP];
dst += dstComponents;
}
}
if (bDst >= 0) {
GLfloat *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[bDst] = rgba[i][BCOMP];
dst += dstComponents;
}
}
if (aDst >= 0) {
GLfloat *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[aDst] = rgba[i][ACOMP];
dst += dstComponents;
}
}
if (iDst >= 0) {
GLfloat *dst = dest;
GLuint i;
assert(iDst == 0);
assert(dstComponents == 1);
for (i = 0; i < n; i++) {
/* Intensity comes from red channel */
dst[i] = rgba[i][RCOMP];
}
}
if (lDst >= 0) {
GLfloat *dst = dest;
GLuint i;
assert(lDst == 0);
for (i = 0; i < n; i++) {
/* Luminance comes from red channel */
dst[0] = rgba[i][RCOMP];
dst += dstComponents;
}
}
free(rgba);
}
}
/**
* Same as _mesa_unpack_color_span_ubyte(), but return GLuint data
* instead of GLubyte.
* No pixel transfer ops are applied.
*/
void
_mesa_unpack_color_span_uint(struct gl_context *ctx,
GLuint n, GLenum dstFormat, GLuint *dest,
GLenum srcFormat, GLenum srcType,
const GLvoid *source,
const struct gl_pixelstore_attrib *srcPacking)
{
GLuint (*rgba)[4] = (GLuint (*)[4]) malloc(n * 4 * sizeof(GLfloat));
if (!rgba) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
return;
}
ASSERT(dstFormat == GL_ALPHA ||
dstFormat == GL_LUMINANCE ||
dstFormat == GL_LUMINANCE_ALPHA ||
dstFormat == GL_INTENSITY ||
dstFormat == GL_RED ||
dstFormat == GL_RG ||
dstFormat == GL_RGB ||
dstFormat == GL_RGBA);
ASSERT(srcFormat == GL_RED ||
srcFormat == GL_GREEN ||
srcFormat == GL_BLUE ||
srcFormat == GL_ALPHA ||
srcFormat == GL_LUMINANCE ||
srcFormat == GL_LUMINANCE_ALPHA ||
srcFormat == GL_INTENSITY ||
srcFormat == GL_RG ||
srcFormat == GL_RGB ||
srcFormat == GL_BGR ||
srcFormat == GL_RGBA ||
srcFormat == GL_BGRA ||
srcFormat == GL_ABGR_EXT ||
srcFormat == GL_RED_INTEGER_EXT ||
srcFormat == GL_GREEN_INTEGER_EXT ||
srcFormat == GL_BLUE_INTEGER_EXT ||
srcFormat == GL_ALPHA_INTEGER_EXT ||
srcFormat == GL_RG_INTEGER ||
srcFormat == GL_RGB_INTEGER_EXT ||
srcFormat == GL_RGBA_INTEGER_EXT ||
srcFormat == GL_BGR_INTEGER_EXT ||
srcFormat == GL_BGRA_INTEGER_EXT ||
srcFormat == GL_LUMINANCE_INTEGER_EXT ||
srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
ASSERT(srcType == GL_UNSIGNED_BYTE ||
srcType == GL_BYTE ||
srcType == GL_UNSIGNED_SHORT ||
srcType == GL_SHORT ||
srcType == GL_UNSIGNED_INT ||
srcType == GL_INT ||
srcType == GL_HALF_FLOAT_ARB ||
srcType == GL_FLOAT ||
srcType == GL_UNSIGNED_BYTE_3_3_2 ||
srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
srcType == GL_UNSIGNED_SHORT_5_6_5 ||
srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
srcType == GL_UNSIGNED_INT_8_8_8_8 ||
srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
srcType == GL_UNSIGNED_INT_10_10_10_2 ||
srcType == GL_UNSIGNED_INT_2_10_10_10_REV ||
srcType == GL_UNSIGNED_INT_5_9_9_9_REV ||
srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
/* Extract image data as uint[4] pixels */
extract_uint_rgba(n, rgba, srcFormat, srcType, source,
srcPacking->SwapBytes);
if (dstFormat == GL_RGBA) {
/* simple case */
memcpy(dest, rgba, 4 * sizeof(GLuint) * n);
}
else {
/* general case */
GLint rDst, gDst, bDst, aDst, lDst, iDst;
GLint dstComponents = _mesa_components_in_format( dstFormat );
assert(dstComponents > 0);
get_component_indexes(dstFormat,
&rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
/* Now pack values in the requested dest format */
if (rDst >= 0) {
GLuint *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[rDst] = rgba[i][RCOMP];
dst += dstComponents;
}
}
if (gDst >= 0) {
GLuint *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[gDst] = rgba[i][GCOMP];
dst += dstComponents;
}
}
if (bDst >= 0) {
GLuint *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[bDst] = rgba[i][BCOMP];
dst += dstComponents;
}
}
if (aDst >= 0) {
GLuint *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[aDst] = rgba[i][ACOMP];
dst += dstComponents;
}
}
if (iDst >= 0) {
GLuint *dst = dest;
GLuint i;
assert(iDst == 0);
assert(dstComponents == 1);
for (i = 0; i < n; i++) {
/* Intensity comes from red channel */
dst[i] = rgba[i][RCOMP];
}
}
if (lDst >= 0) {
GLuint *dst = dest;
GLuint i;
assert(lDst == 0);
for (i = 0; i < n; i++) {
/* Luminance comes from red channel */
dst[0] = rgba[i][RCOMP];
dst += dstComponents;
}
}
}
free(rgba);
}
/**
* Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,
* directly return GLbyte data, no transfer ops apply.
*/
void
_mesa_unpack_dudv_span_byte( struct gl_context *ctx,
GLuint n, GLenum dstFormat, GLbyte dest[],
GLenum srcFormat, GLenum srcType,
const GLvoid *source,
const struct gl_pixelstore_attrib *srcPacking,
GLbitfield transferOps )
{
ASSERT(dstFormat == GL_DUDV_ATI);
ASSERT(srcFormat == GL_DUDV_ATI ||
srcFormat == GL_DU8DV8_ATI);
ASSERT(srcType == GL_UNSIGNED_BYTE ||
srcType == GL_BYTE ||
srcType == GL_UNSIGNED_SHORT ||
srcType == GL_SHORT ||
srcType == GL_UNSIGNED_INT ||
srcType == GL_INT ||
srcType == GL_HALF_FLOAT_ARB ||
srcType == GL_FLOAT);
/* general solution */
{
GLint dstComponents;
GLbyte *dst = dest;
GLuint i;
GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
if (!rgba) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
return;
}
dstComponents = _mesa_components_in_format( dstFormat );
/* source & dest image formats should have been error checked by now */
assert(dstComponents > 0);
/*
* Extract image data and convert to RGBA floats
*/
extract_float_rgba(n, rgba, srcFormat, srcType, source,
srcPacking->SwapBytes);
/* Now determine which color channels we need to produce.
* And determine the dest index (offset) within each color tuple.
*/
/* Now pack results in the requested dstFormat */
for (i = 0; i < n; i++) {
/* not sure - need clamp[-1,1] here? */
dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
dst += dstComponents;
}
free(rgba);
}
}
/*
* Unpack a row of color index data from a client buffer according to
* the pixel unpacking parameters.
* This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
*
* Args: ctx - the context
* n - number of pixels
* dstType - destination data type
* dest - destination array
* srcType - source pixel type
* source - source data pointer
* srcPacking - pixel unpacking parameters
* transferOps - the pixel transfer operations to apply
*/
void
_mesa_unpack_index_span( struct gl_context *ctx, GLuint n,
GLenum dstType, GLvoid *dest,
GLenum srcType, const GLvoid *source,
const struct gl_pixelstore_attrib *srcPacking,
GLbitfield transferOps )
{
ASSERT(srcType == GL_BITMAP ||
srcType == GL_UNSIGNED_BYTE ||
srcType == GL_BYTE ||
srcType == GL_UNSIGNED_SHORT ||
srcType == GL_SHORT ||
srcType == GL_UNSIGNED_INT ||
srcType == GL_INT ||
srcType == GL_HALF_FLOAT_ARB ||
srcType == GL_FLOAT);
ASSERT(dstType == GL_UNSIGNED_BYTE ||
dstType == GL_UNSIGNED_SHORT ||
dstType == GL_UNSIGNED_INT);
transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
/*
* Try simple cases first
*/
if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
&& dstType == GL_UNSIGNED_BYTE) {
memcpy(dest, source, n * sizeof(GLubyte));
}
else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
&& dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
memcpy(dest, source, n * sizeof(GLuint));
}
else {
/*
* general solution
*/
GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
if (!indexes) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
return;
}
extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
srcPacking);
if (transferOps)
_mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
/* convert to dest type */
switch (dstType) {
case GL_UNSIGNED_BYTE:
{
GLubyte *dst = (GLubyte *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = (GLubyte) (indexes[i] & 0xff);
}
}
break;
case GL_UNSIGNED_SHORT:
{
GLuint *dst = (GLuint *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = (GLushort) (indexes[i] & 0xffff);
}
}
break;
case GL_UNSIGNED_INT:
memcpy(dest, indexes, n * sizeof(GLuint));
break;
default:
_mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
}
free(indexes);
}
}
void
_mesa_pack_index_span( struct gl_context *ctx, GLuint n,
GLenum dstType, GLvoid *dest, const GLuint *source,
const struct gl_pixelstore_attrib *dstPacking,
GLbitfield transferOps )
{
GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
if (!indexes) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
return;
}
transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
/* make a copy of input */
memcpy(indexes, source, n * sizeof(GLuint));
_mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
source = indexes;
}
switch (dstType) {
case GL_UNSIGNED_BYTE:
{
GLubyte *dst = (GLubyte *) dest;
GLuint i;
for (i = 0; i < n; i++) {
*dst++ = (GLubyte) source[i];
}
}
break;
case GL_BYTE:
{
GLbyte *dst = (GLbyte *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = (GLbyte) source[i];
}
}
break;
case GL_UNSIGNED_SHORT:
{
GLushort *dst = (GLushort *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = (GLushort) source[i];
}
if (dstPacking->SwapBytes) {
_mesa_swap2( (GLushort *) dst, n );
}
}
break;
case GL_SHORT:
{
GLshort *dst = (GLshort *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = (GLshort) source[i];
}
if (dstPacking->SwapBytes) {
_mesa_swap2( (GLushort *) dst, n );
}
}
break;
case GL_UNSIGNED_INT:
{
GLuint *dst = (GLuint *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = (GLuint) source[i];
}
if (dstPacking->SwapBytes) {
_mesa_swap4( (GLuint *) dst, n );
}
}
break;
case GL_INT:
{
GLint *dst = (GLint *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = (GLint) source[i];
}
if (dstPacking->SwapBytes) {
_mesa_swap4( (GLuint *) dst, n );
}
}
break;
case GL_FLOAT:
{
GLfloat *dst = (GLfloat *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = (GLfloat) source[i];
}
if (dstPacking->SwapBytes) {
_mesa_swap4( (GLuint *) dst, n );
}
}
break;
case GL_HALF_FLOAT_ARB:
{
GLhalfARB *dst = (GLhalfARB *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = _mesa_float_to_half((GLfloat) source[i]);
}
if (dstPacking->SwapBytes) {
_mesa_swap2( (GLushort *) dst, n );
}
}
break;
default:
_mesa_problem(ctx, "bad type in _mesa_pack_index_span");
}
free(indexes);
}
/*
* Unpack a row of stencil data from a client buffer according to
* the pixel unpacking parameters.
* This is (or will be) used by glDrawPixels
*
* Args: ctx - the context
* n - number of pixels
* dstType - destination data type
* dest - destination array
* srcType - source pixel type
* source - source data pointer
* srcPacking - pixel unpacking parameters
* transferOps - apply offset/bias/lookup ops?
*/
void
_mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n,
GLenum dstType, GLvoid *dest,
GLenum srcType, const GLvoid *source,
const struct gl_pixelstore_attrib *srcPacking,
GLbitfield transferOps )
{
ASSERT(srcType == GL_BITMAP ||
srcType == GL_UNSIGNED_BYTE ||
srcType == GL_BYTE ||
srcType == GL_UNSIGNED_SHORT ||
srcType == GL_SHORT ||
srcType == GL_UNSIGNED_INT ||
srcType == GL_INT ||
srcType == GL_UNSIGNED_INT_24_8_EXT ||
srcType == GL_HALF_FLOAT_ARB ||
srcType == GL_FLOAT ||
srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
ASSERT(dstType == GL_UNSIGNED_BYTE ||
dstType == GL_UNSIGNED_SHORT ||
dstType == GL_UNSIGNED_INT ||
dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
/* only shift and offset apply to stencil */
transferOps &= IMAGE_SHIFT_OFFSET_BIT;
/*
* Try simple cases first
*/
if (transferOps == 0 &&
!ctx->Pixel.MapStencilFlag &&
srcType == GL_UNSIGNED_BYTE &&
dstType == GL_UNSIGNED_BYTE) {
memcpy(dest, source, n * sizeof(GLubyte));
}
else if (transferOps == 0 &&
!ctx->Pixel.MapStencilFlag &&
srcType == GL_UNSIGNED_INT &&
dstType == GL_UNSIGNED_INT &&
!srcPacking->SwapBytes) {
memcpy(dest, source, n * sizeof(GLuint));
}
else {
/*
* general solution
*/
GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
if (!indexes) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking");
return;
}
extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
srcPacking);
if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
/* shift and offset indexes */
_mesa_shift_and_offset_ci(ctx, n, indexes);
}
if (ctx->Pixel.MapStencilFlag) {
/* Apply stencil lookup table */
const GLuint mask = ctx->PixelMaps.StoS.Size - 1;
GLuint i;
for (i = 0; i < n; i++) {
indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];
}
}
/* convert to dest type */
switch (dstType) {
case GL_UNSIGNED_BYTE:
{
GLubyte *dst = (GLubyte *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = (GLubyte) (indexes[i] & 0xff);
}
}
break;
case GL_UNSIGNED_SHORT:
{
GLuint *dst = (GLuint *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = (GLushort) (indexes[i] & 0xffff);
}
}
break;
case GL_UNSIGNED_INT:
memcpy(dest, indexes, n * sizeof(GLuint));
break;
case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
{
GLuint *dst = (GLuint *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i*2+1] = indexes[i] & 0xff; /* lower 8 bits */
}
}
break;
default:
_mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
}
free(indexes);
}
}
void
_mesa_pack_stencil_span( struct gl_context *ctx, GLuint n,
GLenum dstType, GLvoid *dest, const GLubyte *source,
const struct gl_pixelstore_attrib *dstPacking )
{
GLubyte *stencil = (GLubyte *) malloc(n * sizeof(GLubyte));
if (!stencil) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing");
return;
}
if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
ctx->Pixel.MapStencilFlag) {
/* make a copy of input */
memcpy(stencil, source, n * sizeof(GLubyte));
_mesa_apply_stencil_transfer_ops(ctx, n, stencil);
source = stencil;
}
switch (dstType) {
case GL_UNSIGNED_BYTE:
memcpy(dest, source, n);
break;
case GL_BYTE:
{
GLbyte *dst = (GLbyte *) dest;
GLuint i;
for (i=0;i<n;i++) {
dst[i] = (GLbyte) (source[i] & 0x7f);
}
}
break;
case GL_UNSIGNED_SHORT:
{
GLushort *dst = (GLushort *) dest;
GLuint i;
for (i=0;i<n;i++) {
dst[i] = (GLushort) source[i];
}
if (dstPacking->SwapBytes) {
_mesa_swap2( (GLushort *) dst, n );
}
}
break;
case GL_SHORT:
{
GLshort *dst = (GLshort *) dest;
GLuint i;
for (i=0;i<n;i++) {
dst[i] = (GLshort) source[i];
}
if (dstPacking->SwapBytes) {
_mesa_swap2( (GLushort *) dst, n );
}
}
break;
case GL_UNSIGNED_INT:
{
GLuint *dst = (GLuint *) dest;
GLuint i;
for (i=0;i<n;i++) {
dst[i] = (GLuint) source[i];
}
if (dstPacking->SwapBytes) {
_mesa_swap4( (GLuint *) dst, n );
}
}
break;
case GL_INT:
{
GLint *dst = (GLint *) dest;
GLuint i;
for (i=0;i<n;i++) {
dst[i] = (GLint) source[i];
}
if (dstPacking->SwapBytes) {
_mesa_swap4( (GLuint *) dst, n );
}
}
break;
case GL_FLOAT:
{
GLfloat *dst = (GLfloat *) dest;
GLuint i;
for (i=0;i<n;i++) {
dst[i] = (GLfloat) source[i];
}
if (dstPacking->SwapBytes) {
_mesa_swap4( (GLuint *) dst, n );
}
}
break;
case GL_HALF_FLOAT_ARB:
{
GLhalfARB *dst = (GLhalfARB *) dest;
GLuint i;
for (i=0;i<n;i++) {
dst[i] = _mesa_float_to_half( (float) source[i] );
}
if (dstPacking->SwapBytes) {
_mesa_swap2( (GLushort *) dst, n );
}
}
break;
case GL_BITMAP:
if (dstPacking->LsbFirst) {
GLubyte *dst = (GLubyte *) dest;
GLint shift = 0;
GLuint i;
for (i = 0; i < n; i++) {
if (shift == 0)
*dst = 0;
*dst |= ((source[i] != 0) << shift);
shift++;
if (shift == 8) {
shift = 0;
dst++;
}
}
}
else {
GLubyte *dst = (GLubyte *) dest;
GLint shift = 7;
GLuint i;
for (i = 0; i < n; i++) {
if (shift == 7)
*dst = 0;
*dst |= ((source[i] != 0) << shift);
shift--;
if (shift < 0) {
shift = 7;
dst++;
}
}
}
break;
default:
_mesa_problem(ctx, "bad type in _mesa_pack_index_span");
}
free(stencil);
}
#define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \
do { \
GLuint i; \
const GLTYPE *src = (const GLTYPE *)source; \
for (i = 0; i < n; i++) { \
GLTYPE value = src[i]; \
if (srcPacking->SwapBytes) { \
if (sizeof(GLTYPE) == 2) { \
SWAP2BYTE(value); \
} else if (sizeof(GLTYPE) == 4) { \
SWAP4BYTE(value); \
} \
} \
depthValues[i] = GLTYPE2FLOAT(value); \
} \
} while (0)
/**
* Unpack a row of depth/z values from memory, returning GLushort, GLuint
* or GLfloat values.
* The glPixelTransfer (scale/bias) params will be applied.
*
* \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
* \param depthMax max value for returned GLushort or GLuint values
* (ignored for GLfloat).
*/
void
_mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
GLenum dstType, GLvoid *dest, GLuint depthMax,
GLenum srcType, const GLvoid *source,
const struct gl_pixelstore_attrib *srcPacking )
{
GLfloat *depthTemp = NULL, *depthValues;
GLboolean needClamp = GL_FALSE;
/* Look for special cases first.
* Not only are these faster, they're less prone to numeric conversion
* problems. Otherwise, converting from an int type to a float then
* back to an int type can introduce errors that will show up as
* artifacts in things like depth peeling which uses glCopyTexImage.
*/
if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) {
if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {
const GLuint *src = (const GLuint *) source;
GLushort *dst = (GLushort *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = src[i] >> 16;
}
return;
}
if (srcType == GL_UNSIGNED_SHORT
&& dstType == GL_UNSIGNED_INT
&& depthMax == 0xffffffff) {
const GLushort *src = (const GLushort *) source;
GLuint *dst = (GLuint *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = src[i] | (src[i] << 16);
}
return;
}
if (srcType == GL_UNSIGNED_INT_24_8
&& dstType == GL_UNSIGNED_INT
&& depthMax == 0xffffff) {
const GLuint *src = (const GLuint *) source;
GLuint *dst = (GLuint *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = src[i] >> 8;
}
return;
}
/* XXX may want to add additional cases here someday */
}
/* general case path follows */
if (dstType == GL_FLOAT) {
depthValues = (GLfloat *) dest;
}
else {
depthTemp = (GLfloat *) malloc(n * sizeof(GLfloat));
if (!depthTemp) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
return;
}
depthValues = depthTemp;
}
/* Convert incoming values to GLfloat. Some conversions will require
* clamping, below.
*/
switch (srcType) {
case GL_BYTE:
DEPTH_VALUES(GLbyte, BYTE_TO_FLOATZ);
needClamp = GL_TRUE;
break;
case GL_UNSIGNED_BYTE:
DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
break;
case GL_SHORT:
DEPTH_VALUES(GLshort, SHORT_TO_FLOATZ);
needClamp = GL_TRUE;
break;
case GL_UNSIGNED_SHORT:
DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);
break;
case GL_INT:
DEPTH_VALUES(GLint, INT_TO_FLOAT);
needClamp = GL_TRUE;
break;
case GL_UNSIGNED_INT:
DEPTH_VALUES(GLuint, UINT_TO_FLOAT);
break;
case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
if (dstType == GL_UNSIGNED_INT_24_8_EXT &&
depthMax == 0xffffff &&
ctx->Pixel.DepthScale == 1.0 &&
ctx->Pixel.DepthBias == 0.0) {
const GLuint *src = (const GLuint *) source;
GLuint *zValues = (GLuint *) dest;
GLuint i;
for (i = 0; i < n; i++) {
GLuint value = src[i];
if (srcPacking->SwapBytes) {
SWAP4BYTE(value);
}
zValues[i] = value & 0xffffff00;
}
free(depthTemp);
return;
}
else {
const GLuint *src = (const GLuint *) source;
const GLfloat scale = 1.0f / 0xffffff;
GLuint i;
for (i = 0; i < n; i++) {
GLuint value = src[i];
if (srcPacking->SwapBytes) {
SWAP4BYTE(value);
}
depthValues[i] = (value >> 8) * scale;
}
}
break;
case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
{
GLuint i;
const GLfloat *src = (const GLfloat *)source;
for (i = 0; i < n; i++) {
GLfloat value = src[i * 2];
if (srcPacking->SwapBytes) {
SWAP4BYTE(value);
}
depthValues[i] = value;
}
needClamp = GL_TRUE;
}
break;
case GL_FLOAT:
DEPTH_VALUES(GLfloat, 1*);
needClamp = GL_TRUE;
break;
case GL_HALF_FLOAT_ARB:
{
GLuint i;
const GLhalfARB *src = (const GLhalfARB *) source;
for (i = 0; i < n; i++) {
GLhalfARB value = src[i];
if (srcPacking->SwapBytes) {
SWAP2BYTE(value);
}
depthValues[i] = _mesa_half_to_float(value);
}
needClamp = GL_TRUE;
}
break;
default:
_mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
free(depthTemp);
return;
}
/* apply depth scale and bias */
{
const GLfloat scale = ctx->Pixel.DepthScale;
const GLfloat bias = ctx->Pixel.DepthBias;
if (scale != 1.0 || bias != 0.0) {
GLuint i;
for (i = 0; i < n; i++) {
depthValues[i] = depthValues[i] * scale + bias;
}
needClamp = GL_TRUE;
}
}
/* clamp to [0, 1] */
if (needClamp) {
GLuint i;
for (i = 0; i < n; i++) {
depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);
}
}
/*
* Convert values to dstType
*/
if (dstType == GL_UNSIGNED_INT) {
GLuint *zValues = (GLuint *) dest;
GLuint i;
if (depthMax <= 0xffffff) {
/* no overflow worries */
for (i = 0; i < n; i++) {
zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax);
}
}
else {
/* need to use double precision to prevent overflow problems */
for (i = 0; i < n; i++) {
GLdouble z = depthValues[i] * (GLdouble) depthMax;
if (z >= (GLdouble) 0xffffffff)
zValues[i] = 0xffffffff;
else
zValues[i] = (GLuint) z;
}
}
}
else if (dstType == GL_UNSIGNED_SHORT) {
GLushort *zValues = (GLushort *) dest;
GLuint i;
ASSERT(depthMax <= 0xffff);
for (i = 0; i < n; i++) {
zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);
}
}
else if (dstType == GL_FLOAT) {
/* Nothing to do. depthValues is pointing to dest. */
}
else if (dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) {
GLfloat *zValues = (GLfloat*) dest;
GLuint i;
for (i = 0; i < n; i++) {
zValues[i*2] = depthValues[i];
}
}
else {
ASSERT(0);
}
free(depthTemp);
}
/*
* Pack an array of depth values. The values are floats in [0,1].
*/
void
_mesa_pack_depth_span( struct gl_context *ctx, GLuint n, GLvoid *dest,
GLenum dstType, const GLfloat *depthSpan,
const struct gl_pixelstore_attrib *dstPacking )
{
GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
if (!depthCopy) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
return;
}
if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
_mesa_scale_and_bias_depth(ctx, n, depthCopy);
depthSpan = depthCopy;
}
switch (dstType) {
case GL_UNSIGNED_BYTE:
{
GLubyte *dst = (GLubyte *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
}
}
break;
case GL_BYTE:
{
GLbyte *dst = (GLbyte *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
}
}
break;
case GL_UNSIGNED_SHORT:
{
GLushort *dst = (GLushort *) dest;
GLuint i;
for (i = 0; i < n; i++) {
CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
}
if (dstPacking->SwapBytes) {
_mesa_swap2( (GLushort *) dst, n );
}
}
break;
case GL_SHORT:
{
GLshort *dst = (GLshort *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
}
if (dstPacking->SwapBytes) {
_mesa_swap2( (GLushort *) dst, n );
}
}
break;
case GL_UNSIGNED_INT:
{
GLuint *dst = (GLuint *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = FLOAT_TO_UINT( depthSpan[i] );
}
if (dstPacking->SwapBytes) {
_mesa_swap4( (GLuint *) dst, n );
}
}
break;
case GL_INT:
{
GLint *dst = (GLint *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = FLOAT_TO_INT( depthSpan[i] );
}
if (dstPacking->SwapBytes) {
_mesa_swap4( (GLuint *) dst, n );
}
}
break;
case GL_FLOAT:
{
GLfloat *dst = (GLfloat *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = depthSpan[i];
}
if (dstPacking->SwapBytes) {
_mesa_swap4( (GLuint *) dst, n );
}
}
break;
case GL_HALF_FLOAT_ARB:
{
GLhalfARB *dst = (GLhalfARB *) dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[i] = _mesa_float_to_half(depthSpan[i]);
}
if (dstPacking->SwapBytes) {
_mesa_swap2( (GLushort *) dst, n );
}
}
break;
default:
_mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
}
free(depthCopy);
}
/**
* Pack depth and stencil values as GL_DEPTH_STENCIL (GL_UNSIGNED_INT_24_8 etc)
*/
void
_mesa_pack_depth_stencil_span(struct gl_context *ctx,GLuint n,
GLenum dstType, GLuint *dest,
const GLfloat *depthVals,
const GLubyte *stencilVals,
const struct gl_pixelstore_attrib *dstPacking)
{
GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
GLubyte *stencilCopy = (GLubyte *) malloc(n * sizeof(GLubyte));
GLuint i;
if (!depthCopy || !stencilCopy) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
free(depthCopy);
free(stencilCopy);
return;
}
if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
_mesa_scale_and_bias_depth(ctx, n, depthCopy);
depthVals = depthCopy;
}
if (ctx->Pixel.IndexShift ||
ctx->Pixel.IndexOffset ||
ctx->Pixel.MapStencilFlag) {
memcpy(stencilCopy, stencilVals, n * sizeof(GLubyte));
_mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
stencilVals = stencilCopy;
}
switch (dstType) {
case GL_UNSIGNED_INT_24_8:
for (i = 0; i < n; i++) {
GLuint z = (GLuint) (depthVals[i] * 0xffffff);
dest[i] = (z << 8) | (stencilVals[i] & 0xff);
}
break;
case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
for (i = 0; i < n; i++) {
((GLfloat*)dest)[i*2] = depthVals[i];
dest[i*2+1] = stencilVals[i] & 0xff;
}
break;
}
if (dstPacking->SwapBytes) {
_mesa_swap4(dest, n);
}
free(depthCopy);
free(stencilCopy);
}
/**
* Unpack image data. Apply byte swapping, byte flipping (bitmap).
* Return all image data in a contiguous block. This is used when we
* compile glDrawPixels, glTexImage, etc into a display list. We
* need a copy of the data in a standard format.
*/
void *
_mesa_unpack_image( GLuint dimensions,
GLsizei width, GLsizei height, GLsizei depth,
GLenum format, GLenum type, const GLvoid *pixels,
const struct gl_pixelstore_attrib *unpack )
{
GLint bytesPerRow, compsPerRow;
GLboolean flipBytes, swap2, swap4;
if (!pixels)
return NULL; /* not necessarily an error */
if (width <= 0 || height <= 0 || depth <= 0)
return NULL; /* generate error later */
if (type == GL_BITMAP) {
bytesPerRow = (width + 7) >> 3;
flipBytes = unpack->LsbFirst;
swap2 = swap4 = GL_FALSE;
compsPerRow = 0;
}
else {
const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
GLint components = _mesa_components_in_format(format);
GLint bytesPerComp;
if (_mesa_type_is_packed(type))
components = 1;
if (bytesPerPixel <= 0 || components <= 0)
return NULL; /* bad format or type. generate error later */
bytesPerRow = bytesPerPixel * width;
bytesPerComp = bytesPerPixel / components;
flipBytes = GL_FALSE;
swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
compsPerRow = components * width;
assert(compsPerRow >= width);
}
{
GLubyte *destBuffer
= (GLubyte *) malloc(bytesPerRow * height * depth);
GLubyte *dst;
GLint img, row;
if (!destBuffer)
return NULL; /* generate GL_OUT_OF_MEMORY later */
dst = destBuffer;
for (img = 0; img < depth; img++) {
for (row = 0; row < height; row++) {
const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
width, height, format, type, img, row, 0);
if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {
GLint i;
flipBytes = GL_FALSE;
if (unpack->LsbFirst) {
GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);
GLubyte dstMask = 128;
const GLubyte *s = src;
GLubyte *d = dst;
*d = 0;
for (i = 0; i < width; i++) {
if (*s & srcMask) {
*d |= dstMask;
}
if (srcMask == 128) {
srcMask = 1;
s++;
}
else {
srcMask = srcMask << 1;
}
if (dstMask == 1) {
dstMask = 128;
d++;
*d = 0;
}
else {
dstMask = dstMask >> 1;
}
}
}
else {
GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);
GLubyte dstMask = 128;
const GLubyte *s = src;
GLubyte *d = dst;
*d = 0;
for (i = 0; i < width; i++) {
if (*s & srcMask) {
*d |= dstMask;
}
if (srcMask == 1) {
srcMask = 128;
s++;
}
else {
srcMask = srcMask >> 1;
}
if (dstMask == 1) {
dstMask = 128;
d++;
*d = 0;
}
else {
dstMask = dstMask >> 1;
}
}
}
}
else {
memcpy(dst, src, bytesPerRow);
}
/* byte flipping/swapping */
if (flipBytes) {
flip_bytes((GLubyte *) dst, bytesPerRow);
}
else if (swap2) {
_mesa_swap2((GLushort*) dst, compsPerRow);
}
else if (swap4) {
_mesa_swap4((GLuint*) dst, compsPerRow);
}
dst += bytesPerRow;
}
}
return destBuffer;
}
}
/**
* If we unpack colors from a luminance surface, we'll get pixel colors
* such as (l, l, l, a).
* When we call _mesa_pack_rgba_span_float(format=GL_LUMINANCE), that
* function will compute L=R+G+B before packing. The net effect is we'll
* accidentally store luminance values = 3*l.
* This function compensates for that by converting (aka rebasing) (l,l,l,a)
* to be (l,0,0,a).
* It's a similar story for other formats such as LUMINANCE_ALPHA, ALPHA
* and INTENSITY.
*
* Finally, we also need to do this when the actual surface format does
* not match the logical surface format. For example, suppose the user
* requests a GL_LUMINANCE texture but the driver stores it as RGBA.
* Again, we'll get pixel values like (l,l,l,a).
*/
void
_mesa_rebase_rgba_float(GLuint n, GLfloat rgba[][4], GLenum baseFormat)
{
GLuint i;
switch (baseFormat) {
case GL_ALPHA:
for (i = 0; i < n; i++) {
rgba[i][RCOMP] = 0.0F;
rgba[i][GCOMP] = 0.0F;
rgba[i][BCOMP] = 0.0F;
}
break;
case GL_INTENSITY:
/* fall-through */
case GL_LUMINANCE:
for (i = 0; i < n; i++) {
rgba[i][GCOMP] = 0.0F;
rgba[i][BCOMP] = 0.0F;
rgba[i][ACOMP] = 1.0F;
}
break;
case GL_LUMINANCE_ALPHA:
for (i = 0; i < n; i++) {
rgba[i][GCOMP] = 0.0F;
rgba[i][BCOMP] = 0.0F;
}
break;
default:
/* no-op */
;
}
}
/**
* As above, but GLuint components.
*/
void
_mesa_rebase_rgba_uint(GLuint n, GLuint rgba[][4], GLenum baseFormat)
{
GLuint i;
switch (baseFormat) {
case GL_ALPHA:
for (i = 0; i < n; i++) {
rgba[i][RCOMP] = 0;
rgba[i][GCOMP] = 0;
rgba[i][BCOMP] = 0;
}
break;
case GL_INTENSITY:
/* fall-through */
case GL_LUMINANCE:
for (i = 0; i < n; i++) {
rgba[i][GCOMP] = 0;
rgba[i][BCOMP] = 0;
rgba[i][ACOMP] = 1;
}
break;
case GL_LUMINANCE_ALPHA:
for (i = 0; i < n; i++) {
rgba[i][GCOMP] = 0;
rgba[i][BCOMP] = 0;
}
break;
default:
/* no-op */
;
}
}