Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / external / mesa3d / 562c127693200822f04a145db50add1be2425d7b / . / src / mesa / main / image.c
blob: fc278bb8afae59a77be1ddba5e7a1b1df4609b6d [file] [log] [blame]
/*
* Mesa 3-D graphics library
* Version: 7.5
*
* Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
* Copyright (C) 2009 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
* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/**
* \file image.c
* Image handling.
*/
#include "glheader.h"
#include "colormac.h"
#include "context.h"
#include "enums.h"
#include "image.h"
#include "imports.h"
#include "macros.h"
#include "pixel.h"
/**
* NOTE:
* Normally, BYTE_TO_FLOAT(0) returns 0.00392 That causes problems when
* we later convert the float to a packed integer value (such as for
* GL_RGB5_A1) because we'll wind up with a non-zero value.
*
* We redefine the macros here so zero is handled correctly.
*/
#undef BYTE_TO_FLOAT
#define BYTE_TO_FLOAT(B) ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F)))
#undef SHORT_TO_FLOAT
#define SHORT_TO_FLOAT(S) ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F)))
/** Compute ceiling of integer quotient of A divided by B. */
#define CEILING( A, B ) ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 )
/**
* \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise.
*/
GLboolean
_mesa_type_is_packed(GLenum type)
{
switch (type) {
case GL_UNSIGNED_BYTE_3_3_2:
case GL_UNSIGNED_BYTE_2_3_3_REV:
case GL_UNSIGNED_SHORT_5_6_5:
case GL_UNSIGNED_SHORT_5_6_5_REV:
case GL_UNSIGNED_SHORT_4_4_4_4:
case GL_UNSIGNED_SHORT_4_4_4_4_REV:
case GL_UNSIGNED_SHORT_5_5_5_1:
case GL_UNSIGNED_SHORT_1_5_5_5_REV:
case GL_UNSIGNED_INT_8_8_8_8:
case GL_UNSIGNED_INT_8_8_8_8_REV:
case GL_UNSIGNED_INT_10_10_10_2:
case GL_UNSIGNED_INT_2_10_10_10_REV:
case GL_UNSIGNED_SHORT_8_8_MESA:
case GL_UNSIGNED_SHORT_8_8_REV_MESA:
case GL_UNSIGNED_INT_24_8_EXT:
return GL_TRUE;
}
return GL_FALSE;
}
/**
* 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;
}
}
/**
* Flip the order of the 2 bytes in each word in the given array.
*
* \param p array.
* \param n number of words.
*/
void
_mesa_swap2( GLushort *p, GLuint n )
{
GLuint i;
for (i = 0; i < n; i++) {
p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00);
}
}
/*
* Flip the order of the 4 bytes in each word in the given array.
*/
void
_mesa_swap4( GLuint *p, GLuint n )
{
GLuint i, a, b;
for (i = 0; i < n; i++) {
b = p[i];
a = (b >> 24)
| ((b >> 8) & 0xff00)
| ((b << 8) & 0xff0000)
| ((b << 24) & 0xff000000);
p[i] = a;
}
}
/**
* Get the size of a GL data type.
*
* \param type GL data type.
*
* \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1
* if an invalid type enum.
*/
GLint
_mesa_sizeof_type( GLenum type )
{
switch (type) {
case GL_BITMAP:
return 0;
case GL_UNSIGNED_BYTE:
return sizeof(GLubyte);
case GL_BYTE:
return sizeof(GLbyte);
case GL_UNSIGNED_SHORT:
return sizeof(GLushort);
case GL_SHORT:
return sizeof(GLshort);
case GL_UNSIGNED_INT:
return sizeof(GLuint);
case GL_INT:
return sizeof(GLint);
case GL_FLOAT:
return sizeof(GLfloat);
case GL_DOUBLE:
return sizeof(GLdouble);
case GL_HALF_FLOAT_ARB:
return sizeof(GLhalfARB);
default:
return -1;
}
}
/**
* Same as _mesa_sizeof_type() but also accepting the packed pixel
* format data types.
*/
GLint
_mesa_sizeof_packed_type( GLenum type )
{
switch (type) {
case GL_BITMAP:
return 0;
case GL_UNSIGNED_BYTE:
return sizeof(GLubyte);
case GL_BYTE:
return sizeof(GLbyte);
case GL_UNSIGNED_SHORT:
return sizeof(GLushort);
case GL_SHORT:
return sizeof(GLshort);
case GL_UNSIGNED_INT:
return sizeof(GLuint);
case GL_INT:
return sizeof(GLint);
case GL_HALF_FLOAT_ARB:
return sizeof(GLhalfARB);
case GL_FLOAT:
return sizeof(GLfloat);
case GL_UNSIGNED_BYTE_3_3_2:
return sizeof(GLubyte);
case GL_UNSIGNED_BYTE_2_3_3_REV:
return sizeof(GLubyte);
case GL_UNSIGNED_SHORT_5_6_5:
return sizeof(GLushort);
case GL_UNSIGNED_SHORT_5_6_5_REV:
return sizeof(GLushort);
case GL_UNSIGNED_SHORT_4_4_4_4:
return sizeof(GLushort);
case GL_UNSIGNED_SHORT_4_4_4_4_REV:
return sizeof(GLushort);
case GL_UNSIGNED_SHORT_5_5_5_1:
return sizeof(GLushort);
case GL_UNSIGNED_SHORT_1_5_5_5_REV:
return sizeof(GLushort);
case GL_UNSIGNED_INT_8_8_8_8:
return sizeof(GLuint);
case GL_UNSIGNED_INT_8_8_8_8_REV:
return sizeof(GLuint);
case GL_UNSIGNED_INT_10_10_10_2:
return sizeof(GLuint);
case GL_UNSIGNED_INT_2_10_10_10_REV:
return sizeof(GLuint);
case GL_UNSIGNED_SHORT_8_8_MESA:
case GL_UNSIGNED_SHORT_8_8_REV_MESA:
return sizeof(GLushort);
case GL_UNSIGNED_INT_24_8_EXT:
return sizeof(GLuint);
default:
return -1;
}
}
/**
* Get the number of components in a pixel format.
*
* \param format pixel format.
*
* \return the number of components in the given format, or -1 if a bad format.
*/
GLint
_mesa_components_in_format( GLenum format )
{
switch (format) {
case GL_COLOR_INDEX:
case GL_COLOR_INDEX1_EXT:
case GL_COLOR_INDEX2_EXT:
case GL_COLOR_INDEX4_EXT:
case GL_COLOR_INDEX8_EXT:
case GL_COLOR_INDEX12_EXT:
case GL_COLOR_INDEX16_EXT:
case GL_STENCIL_INDEX:
case GL_DEPTH_COMPONENT:
case GL_RED:
case GL_GREEN:
case GL_BLUE:
case GL_ALPHA:
case GL_LUMINANCE:
case GL_INTENSITY:
return 1;
case GL_LUMINANCE_ALPHA:
return 2;
case GL_RGB:
return 3;
case GL_RGBA:
return 4;
case GL_BGR:
return 3;
case GL_BGRA:
return 4;
case GL_ABGR_EXT:
return 4;
case GL_YCBCR_MESA:
return 2;
case GL_DEPTH_STENCIL_EXT:
return 2;
case GL_DUDV_ATI:
case GL_DU8DV8_ATI:
return 2;
default:
return -1;
}
}
/**
* Get the bytes per pixel of pixel format type pair.
*
* \param format pixel format.
* \param type pixel type.
*
* \return bytes per pixel, or -1 if a bad format or type was given.
*/
GLint
_mesa_bytes_per_pixel( GLenum format, GLenum type )
{
GLint comps = _mesa_components_in_format( format );
if (comps < 0)
return -1;
switch (type) {
case GL_BITMAP:
return 0; /* special case */
case GL_BYTE:
case GL_UNSIGNED_BYTE:
return comps * sizeof(GLubyte);
case GL_SHORT:
case GL_UNSIGNED_SHORT:
return comps * sizeof(GLshort);
case GL_INT:
case GL_UNSIGNED_INT:
return comps * sizeof(GLint);
case GL_FLOAT:
return comps * sizeof(GLfloat);
case GL_HALF_FLOAT_ARB:
return comps * sizeof(GLhalfARB);
case GL_UNSIGNED_BYTE_3_3_2:
case GL_UNSIGNED_BYTE_2_3_3_REV:
if (format == GL_RGB || format == GL_BGR)
return sizeof(GLubyte);
else
return -1; /* error */
case GL_UNSIGNED_SHORT_5_6_5:
case GL_UNSIGNED_SHORT_5_6_5_REV:
if (format == GL_RGB || format == GL_BGR)
return sizeof(GLushort);
else
return -1; /* error */
case GL_UNSIGNED_SHORT_4_4_4_4:
case GL_UNSIGNED_SHORT_4_4_4_4_REV:
case GL_UNSIGNED_SHORT_5_5_5_1:
case GL_UNSIGNED_SHORT_1_5_5_5_REV:
if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT)
return sizeof(GLushort);
else
return -1;
case GL_UNSIGNED_INT_8_8_8_8:
case GL_UNSIGNED_INT_8_8_8_8_REV:
case GL_UNSIGNED_INT_10_10_10_2:
case GL_UNSIGNED_INT_2_10_10_10_REV:
if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT)
return sizeof(GLuint);
else
return -1;
case GL_UNSIGNED_SHORT_8_8_MESA:
case GL_UNSIGNED_SHORT_8_8_REV_MESA:
if (format == GL_YCBCR_MESA)
return sizeof(GLushort);
else
return -1;
case GL_UNSIGNED_INT_24_8_EXT:
if (format == GL_DEPTH_STENCIL_EXT)
return sizeof(GLuint);
else
return -1;
default:
return -1;
}
}
/**
* Test for a legal pixel format and type.
*
* \param format pixel format.
* \param type pixel type.
*
* \return GL_TRUE if the given pixel format and type are legal, or GL_FALSE
* otherwise.
*/
GLboolean
_mesa_is_legal_format_and_type( GLcontext *ctx, GLenum format, GLenum type )
{
switch (format) {
case GL_COLOR_INDEX:
case GL_STENCIL_INDEX:
switch (type) {
case GL_BITMAP:
case GL_BYTE:
case GL_UNSIGNED_BYTE:
case GL_SHORT:
case GL_UNSIGNED_SHORT:
case GL_INT:
case GL_UNSIGNED_INT:
case GL_FLOAT:
return GL_TRUE;
case GL_HALF_FLOAT_ARB:
return ctx->Extensions.ARB_half_float_pixel;
default:
return GL_FALSE;
}
case GL_RED:
case GL_GREEN:
case GL_BLUE:
case GL_ALPHA:
#if 0 /* not legal! see table 3.6 of the 1.5 spec */
case GL_INTENSITY:
#endif
case GL_LUMINANCE:
case GL_LUMINANCE_ALPHA:
case GL_DEPTH_COMPONENT:
switch (type) {
case GL_BYTE:
case GL_UNSIGNED_BYTE:
case GL_SHORT:
case GL_UNSIGNED_SHORT:
case GL_INT:
case GL_UNSIGNED_INT:
case GL_FLOAT:
return GL_TRUE;
case GL_HALF_FLOAT_ARB:
return ctx->Extensions.ARB_half_float_pixel;
default:
return GL_FALSE;
}
case GL_RGB:
switch (type) {
case GL_BYTE:
case GL_UNSIGNED_BYTE:
case GL_SHORT:
case GL_UNSIGNED_SHORT:
case GL_INT:
case GL_UNSIGNED_INT:
case GL_FLOAT:
case GL_UNSIGNED_BYTE_3_3_2:
case GL_UNSIGNED_BYTE_2_3_3_REV:
case GL_UNSIGNED_SHORT_5_6_5:
case GL_UNSIGNED_SHORT_5_6_5_REV:
return GL_TRUE;
case GL_HALF_FLOAT_ARB:
return ctx->Extensions.ARB_half_float_pixel;
default:
return GL_FALSE;
}
case GL_BGR:
switch (type) {
/* NOTE: no packed types are supported with BGR. That's
* intentional, according to the GL spec.
*/
case GL_BYTE:
case GL_UNSIGNED_BYTE:
case GL_SHORT:
case GL_UNSIGNED_SHORT:
case GL_INT:
case GL_UNSIGNED_INT:
case GL_FLOAT:
return GL_TRUE;
case GL_HALF_FLOAT_ARB:
return ctx->Extensions.ARB_half_float_pixel;
default:
return GL_FALSE;
}
case GL_RGBA:
case GL_BGRA:
case GL_ABGR_EXT:
switch (type) {
case GL_BYTE:
case GL_UNSIGNED_BYTE:
case GL_SHORT:
case GL_UNSIGNED_SHORT:
case GL_INT:
case GL_UNSIGNED_INT:
case GL_FLOAT:
case GL_UNSIGNED_SHORT_4_4_4_4:
case GL_UNSIGNED_SHORT_4_4_4_4_REV:
case GL_UNSIGNED_SHORT_5_5_5_1:
case GL_UNSIGNED_SHORT_1_5_5_5_REV:
case GL_UNSIGNED_INT_8_8_8_8:
case GL_UNSIGNED_INT_8_8_8_8_REV:
case GL_UNSIGNED_INT_10_10_10_2:
case GL_UNSIGNED_INT_2_10_10_10_REV:
return GL_TRUE;
case GL_HALF_FLOAT_ARB:
return ctx->Extensions.ARB_half_float_pixel;
default:
return GL_FALSE;
}
case GL_YCBCR_MESA:
if (type == GL_UNSIGNED_SHORT_8_8_MESA ||
type == GL_UNSIGNED_SHORT_8_8_REV_MESA)
return GL_TRUE;
else
return GL_FALSE;
case GL_DEPTH_STENCIL_EXT:
if (ctx->Extensions.EXT_packed_depth_stencil
&& type == GL_UNSIGNED_INT_24_8_EXT)
return GL_TRUE;
else
return GL_FALSE;
case GL_DUDV_ATI:
case GL_DU8DV8_ATI:
switch (type) {
case GL_BYTE:
case GL_UNSIGNED_BYTE:
case GL_SHORT:
case GL_UNSIGNED_SHORT:
case GL_INT:
case GL_UNSIGNED_INT:
case GL_FLOAT:
return GL_TRUE;
default:
return GL_FALSE;
}
default:
; /* fall-through */
}
return GL_FALSE;
}
/**
* Test if the given image format is a color/RGBA format (i.e., not color
* index, depth, stencil, etc).
* \param format the image format value (may by an internal texture format)
* \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise.
*/
GLboolean
_mesa_is_color_format(GLenum format)
{
switch (format) {
case GL_RED:
case GL_GREEN:
case GL_BLUE:
case GL_ALPHA:
case GL_ALPHA4:
case GL_ALPHA8:
case GL_ALPHA12:
case GL_ALPHA16:
case 1:
case GL_LUMINANCE:
case GL_LUMINANCE4:
case GL_LUMINANCE8:
case GL_LUMINANCE12:
case GL_LUMINANCE16:
case 2:
case GL_LUMINANCE_ALPHA:
case GL_LUMINANCE4_ALPHA4:
case GL_LUMINANCE6_ALPHA2:
case GL_LUMINANCE8_ALPHA8:
case GL_LUMINANCE12_ALPHA4:
case GL_LUMINANCE12_ALPHA12:
case GL_LUMINANCE16_ALPHA16:
case GL_INTENSITY:
case GL_INTENSITY4:
case GL_INTENSITY8:
case GL_INTENSITY12:
case GL_INTENSITY16:
case 3:
case GL_RGB:
case GL_BGR:
case GL_R3_G3_B2:
case GL_RGB4:
case GL_RGB5:
case GL_RGB8:
case GL_RGB10:
case GL_RGB12:
case GL_RGB16:
case 4:
case GL_ABGR_EXT:
case GL_RGBA:
case GL_BGRA:
case GL_RGBA2:
case GL_RGBA4:
case GL_RGB5_A1:
case GL_RGBA8:
case GL_RGB10_A2:
case GL_RGBA12:
case GL_RGBA16:
/* float texture formats */
case GL_ALPHA16F_ARB:
case GL_ALPHA32F_ARB:
case GL_LUMINANCE16F_ARB:
case GL_LUMINANCE32F_ARB:
case GL_LUMINANCE_ALPHA16F_ARB:
case GL_LUMINANCE_ALPHA32F_ARB:
case GL_INTENSITY16F_ARB:
case GL_INTENSITY32F_ARB:
case GL_RGB16F_ARB:
case GL_RGB32F_ARB:
case GL_RGBA16F_ARB:
case GL_RGBA32F_ARB:
/* compressed formats */
case GL_COMPRESSED_ALPHA:
case GL_COMPRESSED_LUMINANCE:
case GL_COMPRESSED_LUMINANCE_ALPHA:
case GL_COMPRESSED_INTENSITY:
case GL_COMPRESSED_RGB:
case GL_COMPRESSED_RGBA:
case GL_RGB_S3TC:
case GL_RGB4_S3TC:
case GL_RGBA_S3TC:
case GL_RGBA4_S3TC:
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
case GL_COMPRESSED_RGB_FXT1_3DFX:
case GL_COMPRESSED_RGBA_FXT1_3DFX:
#if FEATURE_EXT_texture_sRGB
case GL_SRGB_EXT:
case GL_SRGB8_EXT:
case GL_SRGB_ALPHA_EXT:
case GL_SRGB8_ALPHA8_EXT:
case GL_SLUMINANCE_ALPHA_EXT:
case GL_SLUMINANCE8_ALPHA8_EXT:
case GL_SLUMINANCE_EXT:
case GL_SLUMINANCE8_EXT:
case GL_COMPRESSED_SRGB_EXT:
case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_SRGB_ALPHA_EXT:
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
case GL_COMPRESSED_SLUMINANCE_EXT:
case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
#endif /* FEATURE_EXT_texture_sRGB */
return GL_TRUE;
/* signed texture formats */
case GL_RGBA_SNORM:
case GL_RGBA8_SNORM:
return GL_TRUE;
case GL_YCBCR_MESA: /* not considered to be RGB */
/* fall-through */
default:
return GL_FALSE;
}
}
/**
* Test if the given image format is a color index format.
*/
GLboolean
_mesa_is_index_format(GLenum format)
{
switch (format) {
case GL_COLOR_INDEX:
case GL_COLOR_INDEX1_EXT:
case GL_COLOR_INDEX2_EXT:
case GL_COLOR_INDEX4_EXT:
case GL_COLOR_INDEX8_EXT:
case GL_COLOR_INDEX12_EXT:
case GL_COLOR_INDEX16_EXT:
return GL_TRUE;
default:
return GL_FALSE;
}
}
/**
* Test if the given image format is a depth component format.
*/
GLboolean
_mesa_is_depth_format(GLenum format)
{
switch (format) {
case GL_DEPTH_COMPONENT:
case GL_DEPTH_COMPONENT16:
case GL_DEPTH_COMPONENT24:
case GL_DEPTH_COMPONENT32:
return GL_TRUE;
default:
return GL_FALSE;
}
}
/**
* Test if the given image format is a stencil format.
*/
GLboolean
_mesa_is_stencil_format(GLenum format)
{
switch (format) {
case GL_STENCIL_INDEX:
case GL_DEPTH_STENCIL:
return GL_TRUE;
default:
return GL_FALSE;
}
}
/**
* Test if the given image format is a YCbCr format.
*/
GLboolean
_mesa_is_ycbcr_format(GLenum format)
{
switch (format) {
case GL_YCBCR_MESA:
return GL_TRUE;
default:
return GL_FALSE;
}
}
/**
* Test if the given image format is a depth+stencil format.
*/
GLboolean
_mesa_is_depthstencil_format(GLenum format)
{
switch (format) {
case GL_DEPTH24_STENCIL8_EXT:
case GL_DEPTH_STENCIL_EXT:
return GL_TRUE;
default:
return GL_FALSE;
}
}
/**
* Test if the given image format is a dudv format.
*/
GLboolean
_mesa_is_dudv_format(GLenum format)
{
switch (format) {
case GL_DUDV_ATI:
case GL_DU8DV8_ATI:
return GL_TRUE;
default:
return GL_FALSE;
}
}
/**
* Return the address of a specific pixel in an image (1D, 2D or 3D).
*
* Pixel unpacking/packing parameters are observed according to \p packing.
*
* \param dimensions either 1, 2 or 3 to indicate dimensionality of image
* \param image starting address of image data
* \param width the image width
* \param height theimage height
* \param format the pixel format
* \param type the pixel data type
* \param packing the pixelstore attributes
* \param img which image in the volume (0 for 1D or 2D images)
* \param row row of pixel in the image (0 for 1D images)
* \param column column of pixel in the image
*
* \return address of pixel on success, or NULL on error.
*
* \sa gl_pixelstore_attrib.
*/
GLvoid *
_mesa_image_address( GLuint dimensions,
const struct gl_pixelstore_attrib *packing,
const GLvoid *image,
GLsizei width, GLsizei height,
GLenum format, GLenum type,
GLint img, GLint row, GLint column )
{
GLint alignment; /* 1, 2 or 4 */
GLint pixels_per_row;
GLint rows_per_image;
GLint skiprows;
GLint skippixels;
GLint skipimages; /* for 3-D volume images */
GLubyte *pixel_addr;
ASSERT(dimensions >= 1 && dimensions <= 3);
alignment = packing->Alignment;
if (packing->RowLength > 0) {
pixels_per_row = packing->RowLength;
}
else {
pixels_per_row = width;
}
if (packing->ImageHeight > 0) {
rows_per_image = packing->ImageHeight;
}
else {
rows_per_image = height;
}
skippixels = packing->SkipPixels;
/* Note: SKIP_ROWS _is_ used for 1D images */
skiprows = packing->SkipRows;
/* Note: SKIP_IMAGES is only used for 3D images */
skipimages = (dimensions == 3) ? packing->SkipImages : 0;
if (type == GL_BITMAP) {
/* BITMAP data */
GLint comp_per_pixel; /* components per pixel */
GLint bytes_per_comp; /* bytes per component */
GLint bytes_per_row;
GLint bytes_per_image;
/* Compute bytes per component */
bytes_per_comp = _mesa_sizeof_packed_type( type );
if (bytes_per_comp < 0) {
return NULL;
}
/* Compute number of components per pixel */
comp_per_pixel = _mesa_components_in_format( format );
if (comp_per_pixel < 0) {
return NULL;
}
bytes_per_row = alignment
* CEILING( comp_per_pixel*pixels_per_row, 8*alignment );
bytes_per_image = bytes_per_row * rows_per_image;
pixel_addr = (GLubyte *) image
+ (skipimages + img) * bytes_per_image
+ (skiprows + row) * bytes_per_row
+ (skippixels + column) / 8;
}
else {
/* Non-BITMAP data */
GLint bytes_per_pixel, bytes_per_row, remainder, bytes_per_image;
GLint topOfImage;
bytes_per_pixel = _mesa_bytes_per_pixel( format, type );
/* The pixel type and format should have been error checked earlier */
assert(bytes_per_pixel > 0);
bytes_per_row = pixels_per_row * bytes_per_pixel;
remainder = bytes_per_row % alignment;
if (remainder > 0)
bytes_per_row += (alignment - remainder);
ASSERT(bytes_per_row % alignment == 0);
bytes_per_image = bytes_per_row * rows_per_image;
if (packing->Invert) {
/* set pixel_addr to the last row */
topOfImage = bytes_per_row * (height - 1);
bytes_per_row = -bytes_per_row;
}
else {
topOfImage = 0;
}
/* compute final pixel address */
pixel_addr = (GLubyte *) image
+ (skipimages + img) * bytes_per_image
+ topOfImage
+ (skiprows + row) * bytes_per_row
+ (skippixels + column) * bytes_per_pixel;
}
return (GLvoid *) pixel_addr;
}
GLvoid *
_mesa_image_address1d( const struct gl_pixelstore_attrib *packing,
const GLvoid *image,
GLsizei width,
GLenum format, GLenum type,
GLint column )
{
return _mesa_image_address(1, packing, image, width, 1,
format, type, 0, 0, column);
}
GLvoid *
_mesa_image_address2d( const struct gl_pixelstore_attrib *packing,
const GLvoid *image,
GLsizei width, GLsizei height,
GLenum format, GLenum type,
GLint row, GLint column )
{
return _mesa_image_address(2, packing, image, width, height,
format, type, 0, row, column);
}
GLvoid *
_mesa_image_address3d( const struct gl_pixelstore_attrib *packing,
const GLvoid *image,
GLsizei width, GLsizei height,
GLenum format, GLenum type,
GLint img, GLint row, GLint column )
{
return _mesa_image_address(3, packing, image, width, height,
format, type, img, row, column);
}
/**
* Compute the stride (in bytes) between image rows.
*
* \param packing the pixelstore attributes
* \param width image width.
* \param format pixel format.
* \param type pixel data type.
*
* \return the stride in bytes for the given parameters, or -1 if error
*/
GLint
_mesa_image_row_stride( const struct gl_pixelstore_attrib *packing,
GLint width, GLenum format, GLenum type )
{
GLint bytesPerRow, remainder;
ASSERT(packing);
if (type == GL_BITMAP) {
if (packing->RowLength == 0) {
bytesPerRow = (width + 7) / 8;
}
else {
bytesPerRow = (packing->RowLength + 7) / 8;
}
}
else {
/* Non-BITMAP data */
const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
if (bytesPerPixel <= 0)
return -1; /* error */
if (packing->RowLength == 0) {
bytesPerRow = bytesPerPixel * width;
}
else {
bytesPerRow = bytesPerPixel * packing->RowLength;
}
}
remainder = bytesPerRow % packing->Alignment;
if (remainder > 0) {
bytesPerRow += (packing->Alignment - remainder);
}
if (packing->Invert) {
/* negate the bytes per row (negative row stride) */
bytesPerRow = -bytesPerRow;
}
return bytesPerRow;
}
#if _HAVE_FULL_GL
/*
* Compute the stride between images in a 3D texture (in bytes) for the given
* pixel packing parameters and image width, format and type.
*/
GLint
_mesa_image_image_stride( const struct gl_pixelstore_attrib *packing,
GLint width, GLint height,
GLenum format, GLenum type )
{
GLint bytesPerRow, bytesPerImage, remainder;
ASSERT(packing);
if (type == GL_BITMAP) {
if (packing->RowLength == 0) {
bytesPerRow = (width + 7) / 8;
}
else {
bytesPerRow = (packing->RowLength + 7) / 8;
}
}
else {
const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
if (bytesPerPixel <= 0)
return -1; /* error */
if (packing->RowLength == 0) {
bytesPerRow = bytesPerPixel * width;
}
else {
bytesPerRow = bytesPerPixel * packing->RowLength;
}
}
remainder = bytesPerRow % packing->Alignment;
if (remainder > 0)
bytesPerRow += (packing->Alignment - remainder);
if (packing->ImageHeight == 0)
bytesPerImage = bytesPerRow * height;
else
bytesPerImage = bytesPerRow * packing->ImageHeight;
return bytesPerImage;
}
/*
* 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;
}
_mesa_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 *) _mesa_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) {
_mesa_free(buffer);
return NULL;
}
if ((packing->SkipPixels & 7) == 0) {
_mesa_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) {
_mesa_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;
}
}
/**
* "Expand" a bitmap from 1-bit per pixel to 8-bits per pixel.
* This is typically used to convert a bitmap into a GLubyte/pixel texture.
* "On" bits will set texels to \p onValue.
* "Off" bits will not modify texels.
* \param width src bitmap width in pixels
* \param height src bitmap height in pixels
* \param unpack bitmap unpacking state
* \param bitmap the src bitmap data
* \param destBuffer start of dest buffer
* \param destStride row stride in dest buffer
* \param onValue if bit is 1, set destBuffer pixel to this value
*/
void
_mesa_expand_bitmap(GLsizei width, GLsizei height,
const struct gl_pixelstore_attrib *unpack,
const GLubyte *bitmap,
GLubyte *destBuffer, GLint destStride,
GLubyte onValue)
{
const GLubyte *srcRow = (const GLubyte *)
_mesa_image_address2d(unpack, bitmap, width, height,
GL_COLOR_INDEX, GL_BITMAP, 0, 0);
const GLint srcStride = _mesa_image_row_stride(unpack, width,
GL_COLOR_INDEX, GL_BITMAP);
GLint row, col;
#define SET_PIXEL(COL, ROW) \
destBuffer[(ROW) * destStride + (COL)] = onValue;
for (row = 0; row < height; row++) {
const GLubyte *src = srcRow;
if (unpack->LsbFirst) {
/* Lsb first */
GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
for (col = 0; col < width; col++) {
if (*src & mask) {
SET_PIXEL(col, row);
}
if (mask == 128U) {
src++;
mask = 1U;
}
else {
mask = mask << 1;
}
}
/* get ready for next row */
if (mask != 1)
src++;
}
else {
/* Msb first */
GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
for (col = 0; col < width; col++) {
if (*src & mask) {
SET_PIXEL(col, row);
}
if (mask == 1U) {
src++;
mask = 128U;
}
else {
mask = mask >> 1;
}
}
/* get ready for next row */
if (mask != 128)
src++;
}
srcRow += srcStride;
} /* row */
#undef SET_PIXEL
}
/**********************************************************************/
/***** Pixel processing functions ******/
/**********************************************************************/
/*
* Apply scale and bias factors to an array of RGBA pixels.
*/
void
_mesa_scale_and_bias_rgba(GLuint n, GLfloat rgba[][4],
GLfloat rScale, GLfloat gScale,
GLfloat bScale, GLfloat aScale,
GLfloat rBias, GLfloat gBias,
GLfloat bBias, GLfloat aBias)
{
if (rScale != 1.0 || rBias != 0.0) {
GLuint i;
for (i = 0; i < n; i++) {
rgba[i][RCOMP] = rgba[i][RCOMP] * rScale + rBias;
}
}
if (gScale != 1.0 || gBias != 0.0) {
GLuint i;
for (i = 0; i < n; i++) {
rgba[i][GCOMP] = rgba[i][GCOMP] * gScale + gBias;
}
}
if (bScale != 1.0 || bBias != 0.0) {
GLuint i;
for (i = 0; i < n; i++) {
rgba[i][BCOMP] = rgba[i][BCOMP] * bScale + bBias;
}
}
if (aScale != 1.0 || aBias != 0.0) {
GLuint i;
for (i = 0; i < n; i++) {
rgba[i][ACOMP] = rgba[i][ACOMP] * aScale + aBias;
}
}
}
/*
* Apply pixel mapping to an array of floating point RGBA pixels.
*/
void
_mesa_map_rgba( const GLcontext *ctx, GLuint n, GLfloat rgba[][4] )
{
const GLfloat rscale = (GLfloat) (ctx->PixelMaps.RtoR.Size - 1);
const GLfloat gscale = (GLfloat) (ctx->PixelMaps.GtoG.Size - 1);
const GLfloat bscale = (GLfloat) (ctx->PixelMaps.BtoB.Size - 1);
const GLfloat ascale = (GLfloat) (ctx->PixelMaps.AtoA.Size - 1);
const GLfloat *rMap = ctx->PixelMaps.RtoR.Map;
const GLfloat *gMap = ctx->PixelMaps.GtoG.Map;
const GLfloat *bMap = ctx->PixelMaps.BtoB.Map;
const GLfloat *aMap = ctx->PixelMaps.AtoA.Map;
GLuint i;
for (i=0;i<n;i++) {
GLfloat r = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
GLfloat g = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
GLfloat b = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
GLfloat a = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
rgba[i][RCOMP] = rMap[IROUND(r * rscale)];
rgba[i][GCOMP] = gMap[IROUND(g * gscale)];
rgba[i][BCOMP] = bMap[IROUND(b * bscale)];
rgba[i][ACOMP] = aMap[IROUND(a * ascale)];
}
}
/*
* Apply the color matrix and post color matrix scaling and biasing.
*/
void
_mesa_transform_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4])
{
const GLfloat rs = ctx->Pixel.PostColorMatrixScale[0];
const GLfloat rb = ctx->Pixel.PostColorMatrixBias[0];
const GLfloat gs = ctx->Pixel.PostColorMatrixScale[1];
const GLfloat gb = ctx->Pixel.PostColorMatrixBias[1];
const GLfloat bs = ctx->Pixel.PostColorMatrixScale[2];
const GLfloat bb = ctx->Pixel.PostColorMatrixBias[2];
const GLfloat as = ctx->Pixel.PostColorMatrixScale[3];
const GLfloat ab = ctx->Pixel.PostColorMatrixBias[3];
const GLfloat *m = ctx->ColorMatrixStack.Top->m;
GLuint i;
for (i = 0; i < n; i++) {
const GLfloat r = rgba[i][RCOMP];
const GLfloat g = rgba[i][GCOMP];
const GLfloat b = rgba[i][BCOMP];
const GLfloat a = rgba[i][ACOMP];
rgba[i][RCOMP] = (m[0] * r + m[4] * g + m[ 8] * b + m[12] * a) * rs + rb;
rgba[i][GCOMP] = (m[1] * r + m[5] * g + m[ 9] * b + m[13] * a) * gs + gb;
rgba[i][BCOMP] = (m[2] * r + m[6] * g + m[10] * b + m[14] * a) * bs + bb;
rgba[i][ACOMP] = (m[3] * r + m[7] * g + m[11] * b + m[15] * a) * as + ab;
}
}
/**
* Apply a color table lookup to an array of floating point RGBA colors.
*/
void
_mesa_lookup_rgba_float(const struct gl_color_table *table,
GLuint n, GLfloat rgba[][4])
{
const GLint max = table->Size - 1;
const GLfloat scale = (GLfloat) max;
const GLfloat *lut = table->TableF;
GLuint i;
if (!table->TableF || table->Size == 0)
return;
switch (table->_BaseFormat) {
case GL_INTENSITY:
/* replace RGBA with I */
for (i = 0; i < n; i++) {
GLint j = IROUND(rgba[i][RCOMP] * scale);
GLfloat c = lut[CLAMP(j, 0, max)];
rgba[i][RCOMP] =
rgba[i][GCOMP] =
rgba[i][BCOMP] =
rgba[i][ACOMP] = c;
}
break;
case GL_LUMINANCE:
/* replace RGB with L */
for (i = 0; i < n; i++) {
GLint j = IROUND(rgba[i][RCOMP] * scale);
GLfloat c = lut[CLAMP(j, 0, max)];
rgba[i][RCOMP] =
rgba[i][GCOMP] =
rgba[i][BCOMP] = c;
}
break;
case GL_ALPHA:
/* replace A with A */
for (i = 0; i < n; i++) {
GLint j = IROUND(rgba[i][ACOMP] * scale);
rgba[i][ACOMP] = lut[CLAMP(j, 0, max)];
}
break;
case GL_LUMINANCE_ALPHA:
/* replace RGBA with LLLA */
for (i = 0; i < n; i++) {
GLint jL = IROUND(rgba[i][RCOMP] * scale);
GLint jA = IROUND(rgba[i][ACOMP] * scale);
GLfloat luminance, alpha;
jL = CLAMP(jL, 0, max);
jA = CLAMP(jA, 0, max);
luminance = lut[jL * 2 + 0];
alpha = lut[jA * 2 + 1];
rgba[i][RCOMP] =
rgba[i][GCOMP] =
rgba[i][BCOMP] = luminance;
rgba[i][ACOMP] = alpha;;
}
break;
case GL_RGB:
/* replace RGB with RGB */
for (i = 0; i < n; i++) {
GLint jR = IROUND(rgba[i][RCOMP] * scale);
GLint jG = IROUND(rgba[i][GCOMP] * scale);
GLint jB = IROUND(rgba[i][BCOMP] * scale);
jR = CLAMP(jR, 0, max);
jG = CLAMP(jG, 0, max);
jB = CLAMP(jB, 0, max);
rgba[i][RCOMP] = lut[jR * 3 + 0];
rgba[i][GCOMP] = lut[jG * 3 + 1];
rgba[i][BCOMP] = lut[jB * 3 + 2];
}
break;
case GL_RGBA:
/* replace RGBA with RGBA */
for (i = 0; i < n; i++) {
GLint jR = IROUND(rgba[i][RCOMP] * scale);
GLint jG = IROUND(rgba[i][GCOMP] * scale);
GLint jB = IROUND(rgba[i][BCOMP] * scale);
GLint jA = IROUND(rgba[i][ACOMP] * scale);
jR = CLAMP(jR, 0, max);
jG = CLAMP(jG, 0, max);
jB = CLAMP(jB, 0, max);
jA = CLAMP(jA, 0, max);
rgba[i][RCOMP] = lut[jR * 4 + 0];
rgba[i][GCOMP] = lut[jG * 4 + 1];
rgba[i][BCOMP] = lut[jB * 4 + 2];
rgba[i][ACOMP] = lut[jA * 4 + 3];
}
break;
default:
_mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_float");
return;
}
}
/**
* Apply a color table lookup to an array of ubyte/RGBA colors.
*/
void
_mesa_lookup_rgba_ubyte(const struct gl_color_table *table,
GLuint n, GLubyte rgba[][4])
{
const GLubyte *lut = table->TableUB;
const GLfloat scale = (GLfloat) (table->Size - 1) / (GLfloat)255.0;
GLuint i;
if (!table->TableUB || table->Size == 0)
return;
switch (table->_BaseFormat) {
case GL_INTENSITY:
/* replace RGBA with I */
if (table->Size == 256) {
for (i = 0; i < n; i++) {
const GLubyte c = lut[rgba[i][RCOMP]];
rgba[i][RCOMP] =
rgba[i][GCOMP] =
rgba[i][BCOMP] =
rgba[i][ACOMP] = c;
}
}
else {
for (i = 0; i < n; i++) {
GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
rgba[i][RCOMP] =
rgba[i][GCOMP] =
rgba[i][BCOMP] =
rgba[i][ACOMP] = lut[j];
}
}
break;
case GL_LUMINANCE:
/* replace RGB with L */
if (table->Size == 256) {
for (i = 0; i < n; i++) {
const GLubyte c = lut[rgba[i][RCOMP]];
rgba[i][RCOMP] =
rgba[i][GCOMP] =
rgba[i][BCOMP] = c;
}
}
else {
for (i = 0; i < n; i++) {
GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
rgba[i][RCOMP] =
rgba[i][GCOMP] =
rgba[i][BCOMP] = lut[j];
}
}
break;
case GL_ALPHA:
/* replace A with A */
if (table->Size == 256) {
for (i = 0; i < n; i++) {
rgba[i][ACOMP] = lut[rgba[i][ACOMP]];
}
}
else {
for (i = 0; i < n; i++) {
GLint j = IROUND((GLfloat) rgba[i][ACOMP] * scale);
rgba[i][ACOMP] = lut[j];
}
}
break;
case GL_LUMINANCE_ALPHA:
/* replace RGBA with LLLA */
if (table->Size == 256) {
for (i = 0; i < n; i++) {
GLubyte l = lut[rgba[i][RCOMP] * 2 + 0];
GLubyte a = lut[rgba[i][ACOMP] * 2 + 1];;
rgba[i][RCOMP] =
rgba[i][GCOMP] =
rgba[i][BCOMP] = l;
rgba[i][ACOMP] = a;
}
}
else {
for (i = 0; i < n; i++) {
GLint jL = IROUND((GLfloat) rgba[i][RCOMP] * scale);
GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
GLubyte luminance = lut[jL * 2 + 0];
GLubyte alpha = lut[jA * 2 + 1];
rgba[i][RCOMP] =
rgba[i][GCOMP] =
rgba[i][BCOMP] = luminance;
rgba[i][ACOMP] = alpha;
}
}
break;
case GL_RGB:
if (table->Size == 256) {
for (i = 0; i < n; i++) {
rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 3 + 0];
rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 3 + 1];
rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 3 + 2];
}
}
else {
for (i = 0; i < n; i++) {
GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
rgba[i][RCOMP] = lut[jR * 3 + 0];
rgba[i][GCOMP] = lut[jG * 3 + 1];
rgba[i][BCOMP] = lut[jB * 3 + 2];
}
}
break;
case GL_RGBA:
if (table->Size == 256) {
for (i = 0; i < n; i++) {
rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 4 + 0];
rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 4 + 1];
rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 4 + 2];
rgba[i][ACOMP] = lut[rgba[i][ACOMP] * 4 + 3];
}
}
else {
for (i = 0; i < n; i++) {
GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 4 + 0]);
CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 4 + 1]);
CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 4 + 2]);
CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], lut[jA * 4 + 3]);
}
}
break;
default:
_mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_chan");
return;
}
}
/*
* Map color indexes to float rgba values.
*/
void
_mesa_map_ci_to_rgba( const GLcontext *ctx, GLuint n,
const GLuint index[], GLfloat rgba[][4] )
{
GLuint rmask = ctx->PixelMaps.ItoR.Size - 1;
GLuint gmask = ctx->PixelMaps.ItoG.Size - 1;
GLuint bmask = ctx->PixelMaps.ItoB.Size - 1;
GLuint amask = ctx->PixelMaps.ItoA.Size - 1;
const GLfloat *rMap = ctx->PixelMaps.ItoR.Map;
const GLfloat *gMap = ctx->PixelMaps.ItoG.Map;
const GLfloat *bMap = ctx->PixelMaps.ItoB.Map;
const GLfloat *aMap = ctx->PixelMaps.ItoA.Map;
GLuint i;
for (i=0;i<n;i++) {
rgba[i][RCOMP] = rMap[index[i] & rmask];
rgba[i][GCOMP] = gMap[index[i] & gmask];
rgba[i][BCOMP] = bMap[index[i] & bmask];
rgba[i][ACOMP] = aMap[index[i] & amask];
}
}
/**
* Map ubyte color indexes to ubyte/RGBA values.
*/
void
_mesa_map_ci8_to_rgba8(const GLcontext *ctx, GLuint n, const GLubyte index[],
GLubyte rgba[][4])
{
GLuint rmask = ctx->PixelMaps.ItoR.Size - 1;
GLuint gmask = ctx->PixelMaps.ItoG.Size - 1;
GLuint bmask = ctx->PixelMaps.ItoB.Size - 1;
GLuint amask = ctx->PixelMaps.ItoA.Size - 1;
const GLubyte *rMap = ctx->PixelMaps.ItoR.Map8;
const GLubyte *gMap = ctx->PixelMaps.ItoG.Map8;
const GLubyte *bMap = ctx->PixelMaps.ItoB.Map8;
const GLubyte *aMap = ctx->PixelMaps.ItoA.Map8;
GLuint i;
for (i=0;i<n;i++) {
rgba[i][RCOMP] = rMap[index[i] & rmask];
rgba[i][GCOMP] = gMap[index[i] & gmask];
rgba[i][BCOMP] = bMap[index[i] & bmask];
rgba[i][ACOMP] = aMap[index[i] & amask];
}
}
void
_mesa_scale_and_bias_depth(const GLcontext *ctx, GLuint n,
GLfloat depthValues[])
{
const GLfloat scale = ctx->Pixel.DepthScale;
const GLfloat bias = ctx->Pixel.DepthBias;
GLuint i;
for (i = 0; i < n; i++) {
GLfloat d = depthValues[i] * scale + bias;
depthValues[i] = CLAMP(d, 0.0F, 1.0F);
}
}
void
_mesa_scale_and_bias_depth_uint(const GLcontext *ctx, GLuint n,
GLuint depthValues[])
{
const GLdouble max = (double) 0xffffffff;
const GLdouble scale = ctx->Pixel.DepthScale;
const GLdouble bias = ctx->Pixel.DepthBias * max;
GLuint i;
for (i = 0; i < n; i++) {
GLdouble d = (GLdouble) depthValues[i] * scale + bias;
d = CLAMP(d, 0.0, max);
depthValues[i] = (GLuint) d;
}
}
/*
* Update the min/max values from an array of fragment colors.
*/
static void
update_minmax(GLcontext *ctx, GLuint n, const GLfloat rgba[][4])
{
GLuint i;
for (i = 0; i < n; i++) {
/* update mins */
if (rgba[i][RCOMP] < ctx->MinMax.Min[RCOMP])
ctx->MinMax.Min[RCOMP] = rgba[i][RCOMP];
if (rgba[i][GCOMP] < ctx->MinMax.Min[GCOMP])
ctx->MinMax.Min[GCOMP] = rgba[i][GCOMP];
if (rgba[i][BCOMP] < ctx->MinMax.Min[BCOMP])
ctx->MinMax.Min[BCOMP] = rgba[i][BCOMP];
if (rgba[i][ACOMP] < ctx->MinMax.Min[ACOMP])
ctx->MinMax.Min[ACOMP] = rgba[i][ACOMP];
/* update maxs */
if (rgba[i][RCOMP] > ctx->MinMax.Max[RCOMP])
ctx->MinMax.Max[RCOMP] = rgba[i][RCOMP];
if (rgba[i][GCOMP] > ctx->MinMax.Max[GCOMP])
ctx->MinMax.Max[GCOMP] = rgba[i][GCOMP];
if (rgba[i][BCOMP] > ctx->MinMax.Max[BCOMP])
ctx->MinMax.Max[BCOMP] = rgba[i][BCOMP];
if (rgba[i][ACOMP] > ctx->MinMax.Max[ACOMP])
ctx->MinMax.Max[ACOMP] = rgba[i][ACOMP];
}
}
/*
* Update the histogram values from an array of fragment colors.
*/
static void
update_histogram(GLcontext *ctx, GLuint n, const GLfloat rgba[][4])
{
const GLint max = ctx->Histogram.Width - 1;
GLfloat w = (GLfloat) max;
GLuint i;
if (ctx->Histogram.Width == 0)
return;
for (i = 0; i < n; i++) {
GLint ri = IROUND(rgba[i][RCOMP] * w);
GLint gi = IROUND(rgba[i][GCOMP] * w);
GLint bi = IROUND(rgba[i][BCOMP] * w);
GLint ai = IROUND(rgba[i][ACOMP] * w);
ri = CLAMP(ri, 0, max);
gi = CLAMP(gi, 0, max);
bi = CLAMP(bi, 0, max);
ai = CLAMP(ai, 0, max);
ctx->Histogram.Count[ri][RCOMP]++;
ctx->Histogram.Count[gi][GCOMP]++;
ctx->Histogram.Count[bi][BCOMP]++;
ctx->Histogram.Count[ai][ACOMP]++;
}
}
/**
* Apply various pixel transfer operations to an array of RGBA pixels
* as indicated by the transferOps bitmask
*/
void
_mesa_apply_rgba_transfer_ops(GLcontext *ctx, GLbitfield transferOps,
GLuint n, GLfloat rgba[][4])
{
/* scale & bias */
if (transferOps & IMAGE_SCALE_BIAS_BIT) {
_mesa_scale_and_bias_rgba(n, rgba,
ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
}
/* color map lookup */
if (transferOps & IMAGE_MAP_COLOR_BIT) {
_mesa_map_rgba( ctx, n, rgba );
}
/* GL_COLOR_TABLE lookup */
if (transferOps & IMAGE_COLOR_TABLE_BIT) {
_mesa_lookup_rgba_float(&ctx->ColorTable[COLORTABLE_PRECONVOLUTION], n, rgba);
}
/* convolution */
if (transferOps & IMAGE_CONVOLUTION_BIT) {
/* this has to be done in the calling code */
_mesa_problem(ctx, "IMAGE_CONVOLUTION_BIT set in _mesa_apply_transfer_ops");
}
/* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) {
_mesa_scale_and_bias_rgba(n, rgba,
ctx->Pixel.PostConvolutionScale[RCOMP],
ctx->Pixel.PostConvolutionScale[GCOMP],
ctx->Pixel.PostConvolutionScale[BCOMP],
ctx->Pixel.PostConvolutionScale[ACOMP],
ctx->Pixel.PostConvolutionBias[RCOMP],
ctx->Pixel.PostConvolutionBias[GCOMP],
ctx->Pixel.PostConvolutionBias[BCOMP],
ctx->Pixel.PostConvolutionBias[ACOMP]);
}
/* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
_mesa_lookup_rgba_float(&ctx->ColorTable[COLORTABLE_POSTCONVOLUTION], n, rgba);
}
/* color matrix transform */
if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
_mesa_transform_rgba(ctx, n, rgba);
}
/* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
_mesa_lookup_rgba_float(&ctx->ColorTable[COLORTABLE_POSTCOLORMATRIX], n, rgba);
}
/* update histogram count */
if (transferOps & IMAGE_HISTOGRAM_BIT) {
update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
}
/* update min/max values */
if (transferOps & IMAGE_MIN_MAX_BIT) {
update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
}
/* clamping to [0,1] */
if (transferOps & IMAGE_CLAMP_BIT) {
GLuint i;
for (i = 0; i < n; i++) {
rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
}
}
}
/*
* Apply color index shift and offset to an array of pixels.
*/
static void
shift_and_offset_ci( const GLcontext *ctx, GLuint n, GLuint indexes[] )
{
GLint shift = ctx->Pixel.IndexShift;
GLint offset = ctx->Pixel.IndexOffset;
GLuint i;
if (shift > 0) {
for (i=0;i<n;i++) {
indexes[i] = (indexes[i] << shift) + offset;
}
}
else if (shift < 0) {
shift = -shift;
for (i=0;i<n;i++) {
indexes[i] = (indexes[i] >> shift) + offset;
}
}
else {
for (i=0;i<n;i++) {
indexes[i] = indexes[i] + offset;
}
}
}
/**
* Apply color index shift, offset and table lookup to an array
* of color indexes;
*/
void
_mesa_apply_ci_transfer_ops(const GLcontext *ctx, GLbitfield transferOps,
GLuint n, GLuint indexes[])
{
if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
shift_and_offset_ci(ctx, n, indexes);
}
if (transferOps & IMAGE_MAP_COLOR_BIT) {
const GLuint mask = ctx->PixelMaps.ItoI.Size - 1;
GLuint i;
for (i = 0; i < n; i++) {
const GLuint j = indexes[i] & mask;
indexes[i] = IROUND(ctx->PixelMaps.ItoI.Map[j]);
}
}
}
/**
* Apply stencil index shift, offset and table lookup to an array
* of stencil values.
*/
void
_mesa_apply_stencil_transfer_ops(const GLcontext *ctx, GLuint n,
GLstencil stencil[])
{
if (ctx->Pixel.IndexShift != 0 || ctx->Pixel.IndexOffset != 0) {
const GLint offset = ctx->Pixel.IndexOffset;
GLint shift = ctx->Pixel.IndexShift;
GLuint i;
if (shift > 0) {
for (i = 0; i < n; i++) {
stencil[i] = (stencil[i] << shift) + offset;
}
}
else if (shift < 0) {
shift = -shift;
for (i = 0; i < n; i++) {
stencil[i] = (stencil[i] >> shift) + offset;
}
}
else {
for (i = 0; i < n; i++) {
stencil[i] = stencil[i] + offset;
}
}
}
if (ctx->Pixel.MapStencilFlag) {
GLuint mask = ctx->PixelMaps.StoS.Size - 1;
GLuint i;
for (i = 0; i < n; i++) {
stencil[i] = (GLstencil)ctx->PixelMaps.StoS.Map[ stencil[i] & mask ];
}
}
}
/**
* Used to pack an array [][4] of RGBA float colors as specified
* by the dstFormat, dstType and dstPacking. Used by glReadPixels,
* glGetConvolutionFilter(), etc.
* Note: the rgba values will be modified by this function when any pixel
* transfer ops are enabled.
*/
void
_mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
GLenum dstFormat, GLenum dstType,
GLvoid *dstAddr,
const struct gl_pixelstore_attrib *dstPacking,
GLbitfield transferOps)
{
GLfloat luminance[MAX_WIDTH];
const GLint comps = _mesa_components_in_format(dstFormat);
GLuint i;
/* XXX
* This test should probably go away. Have the caller set/clear the
* IMAGE_CLAMP_BIT as needed.
*/
if (dstType != GL_FLOAT || ctx->Color.ClampReadColor == GL_TRUE) {
/* need to clamp to [0, 1] */
transferOps |= IMAGE_CLAMP_BIT;
}
if (transferOps) {
_mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
if ((transferOps & IMAGE_MIN_MAX_BIT) && ctx->MinMax.Sink) {
return;
}
}
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_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_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_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_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_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_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_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_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_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_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_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;
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_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_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] = (IROUND(rgba[i][RCOMP] * 7.0F) << 5)
| (IROUND(rgba[i][GCOMP] * 7.0F) << 2)
| (IROUND(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] = (IROUND(rgba[i][RCOMP] * 7.0F) )
| (IROUND(rgba[i][GCOMP] * 7.0F) << 3)
| (IROUND(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] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)
| (IROUND(rgba[i][GCOMP] * 63.0F) << 5)
| (IROUND(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] = (IROUND(rgba[i][RCOMP] * 31.0F) )
| (IROUND(rgba[i][GCOMP] * 63.0F) << 5)
| (IROUND(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] = (IROUND(rgba[i][RCOMP] * 15.0F) << 12)
| (IROUND(rgba[i][GCOMP] * 15.0F) << 8)
| (IROUND(rgba[i][BCOMP] * 15.0F) << 4)
| (IROUND(rgba[i][ACOMP] * 15.0F) );
}
}
else if (dstFormat == GL_BGRA) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F) << 12)
| (IROUND(rgba[i][GCOMP] * 15.0F) << 8)
| (IROUND(rgba[i][RCOMP] * 15.0F) << 4)
| (IROUND(rgba[i][ACOMP] * 15.0F) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F) << 12)
| (IROUND(rgba[i][BCOMP] * 15.0F) << 8)
| (IROUND(rgba[i][GCOMP] * 15.0F) << 4)
| (IROUND(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] = (IROUND(rgba[i][RCOMP] * 15.0F) )
| (IROUND(rgba[i][GCOMP] * 15.0F) << 4)
| (IROUND(rgba[i][BCOMP] * 15.0F) << 8)
| (IROUND(rgba[i][ACOMP] * 15.0F) << 12);
}
}
else if (dstFormat == GL_BGRA) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F) )
| (IROUND(rgba[i][GCOMP] * 15.0F) << 4)
| (IROUND(rgba[i][RCOMP] * 15.0F) << 8)
| (IROUND(rgba[i][ACOMP] * 15.0F) << 12);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F) )
| (IROUND(rgba[i][BCOMP] * 15.0F) << 4)
| (IROUND(rgba[i][GCOMP] * 15.0F) << 8)
| (IROUND(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] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)
| (IROUND(rgba[i][GCOMP] * 31.0F) << 6)
| (IROUND(rgba[i][BCOMP] * 31.0F) << 1)
| (IROUND(rgba[i][ACOMP] * 1.0F) );
}
}
else if (dstFormat == GL_BGRA) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F) << 11)
| (IROUND(rgba[i][GCOMP] * 31.0F) << 6)
| (IROUND(rgba[i][RCOMP] * 31.0F) << 1)
| (IROUND(rgba[i][ACOMP] * 1.0F) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F) << 11)
| (IROUND(rgba[i][BCOMP] * 31.0F) << 6)
| (IROUND(rgba[i][GCOMP] * 31.0F) << 1)
| (IROUND(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] = (IROUND(rgba[i][RCOMP] * 31.0F) )
| (IROUND(rgba[i][GCOMP] * 31.0F) << 5)
| (IROUND(rgba[i][BCOMP] * 31.0F) << 10)
| (IROUND(rgba[i][ACOMP] * 1.0F) << 15);
}
}
else if (dstFormat == GL_BGRA) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F) )
| (IROUND(rgba[i][GCOMP] * 31.0F) << 5)
| (IROUND(rgba[i][RCOMP] * 31.0F) << 10)
| (IROUND(rgba[i][ACOMP] * 1.0F) << 15);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLushort *dst = (GLushort *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F) )
| (IROUND(rgba[i][BCOMP] * 31.0F) << 5)
| (IROUND(rgba[i][GCOMP] * 31.0F) << 10)
| (IROUND(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] = (IROUND(rgba[i][RCOMP] * 255.F) << 24)
| (IROUND(rgba[i][GCOMP] * 255.F) << 16)
| (IROUND(rgba[i][BCOMP] * 255.F) << 8)
| (IROUND(rgba[i][ACOMP] * 255.F) );
}
}
else if (dstFormat == GL_BGRA) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][BCOMP] * 255.F) << 24)
| (IROUND(rgba[i][GCOMP] * 255.F) << 16)
| (IROUND(rgba[i][RCOMP] * 255.F) << 8)
| (IROUND(rgba[i][ACOMP] * 255.F) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][ACOMP] * 255.F) << 24)
| (IROUND(rgba[i][BCOMP] * 255.F) << 16)
| (IROUND(rgba[i][GCOMP] * 255.F) << 8)
| (IROUND(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] = (IROUND(rgba[i][RCOMP] * 255.0F) )
| (IROUND(rgba[i][GCOMP] * 255.0F) << 8)
| (IROUND(rgba[i][BCOMP] * 255.0F) << 16)
| (IROUND(rgba[i][ACOMP] * 255.0F) << 24);
}
}
else if (dstFormat == GL_BGRA) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][BCOMP] * 255.0F) )
| (IROUND(rgba[i][GCOMP] * 255.0F) << 8)
| (IROUND(rgba[i][RCOMP] * 255.0F) << 16)
| (IROUND(rgba[i][ACOMP] * 255.0F) << 24);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][ACOMP] * 255.0F) )
| (IROUND(rgba[i][BCOMP] * 255.0F) << 8)
| (IROUND(rgba[i][GCOMP] * 255.0F) << 16)
| (IROUND(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] = (IROUND(rgba[i][RCOMP] * 1023.0F) << 22)
| (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)
| (IROUND(rgba[i][BCOMP] * 1023.0F) << 2)
| (IROUND(rgba[i][ACOMP] * 3.0F) );
}
}
else if (dstFormat == GL_BGRA) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F) << 22)
| (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)
| (IROUND(rgba[i][RCOMP] * 1023.0F) << 2)
| (IROUND(rgba[i][ACOMP] * 3.0F) );
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F) << 22)
| (IROUND(rgba[i][BCOMP] * 1023.0F) << 12)
| (IROUND(rgba[i][GCOMP] * 1023.0F) << 2)
| (IROUND(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] = (IROUND(rgba[i][RCOMP] * 1023.0F) )
| (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)
| (IROUND(rgba[i][BCOMP] * 1023.0F) << 20)
| (IROUND(rgba[i][ACOMP] * 3.0F) << 30);
}
}
else if (dstFormat == GL_BGRA) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F) )
| (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)
| (IROUND(rgba[i][RCOMP] * 1023.0F) << 20)
| (IROUND(rgba[i][ACOMP] * 3.0F) << 30);
}
}
else if (dstFormat == GL_ABGR_EXT) {
GLuint *dst = (GLuint *) dstAddr;
for (i=0;i<n;i++) {
dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F) )
| (IROUND(rgba[i][BCOMP] * 1023.0F) << 10)
| (IROUND(rgba[i][GCOMP] * 1023.0F) << 20)
| (IROUND(rgba[i][RCOMP] * 3.0F) << 30);
}
}
break;
default:
_mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");
return;
}
if (dstPacking->SwapBytes) {
GLint swapSize = _mesa_sizeof_packed_type(dstType);
if (swapSize == 2) {
if (dstPacking->SwapBytes) {
_mesa_swap2((GLushort *) dstAddr, n * comps);
}
}
else if (swapSize == 4) {
if (dstPacking->SwapBytes) {
_mesa_swap4((GLuint *) dstAddr, n * comps);
}
}
}
}
#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);
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;
default:
_mesa_problem(NULL, "bad srcType in extract_uint_indexes");
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 redIndex, greenIndex, blueIndex, alphaIndex;
GLint stride;
GLint rComp, bComp, gComp, aComp;
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_RGB ||
srcFormat == GL_BGR ||
srcFormat == GL_RGBA ||
srcFormat == GL_BGRA ||
srcFormat == GL_ABGR_EXT ||
srcFormat == GL_DU8DV8_ATI ||
srcFormat == GL_DUDV_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 ||
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);
rComp = gComp = bComp = aComp = -1;
switch (srcFormat) {
case GL_RED:
redIndex = 0;
greenIndex = blueIndex = alphaIndex = -1;
stride = 1;
break;
case GL_GREEN:
greenIndex = 0;
redIndex = blueIndex = alphaIndex = -1;
stride = 1;
break;
case GL_BLUE:
blueIndex = 0;
redIndex = greenIndex = alphaIndex = -1;
stride = 1;
break;
case GL_ALPHA:
redIndex = greenIndex = blueIndex = -1;
alphaIndex = 0;
stride = 1;
break;
case GL_LUMINANCE:
redIndex = greenIndex = blueIndex = 0;
alphaIndex = -1;
stride = 1;
break;
case GL_LUMINANCE_ALPHA:
redIndex = greenIndex = blueIndex = 0;
alphaIndex = 1;
stride = 2;
break;
case GL_INTENSITY:
redIndex = greenIndex = blueIndex = alphaIndex = 0;
stride = 1;
break;
case GL_RGB:
redIndex = 0;
greenIndex = 1;
blueIndex = 2;
alphaIndex = -1;
rComp = 0;
gComp = 1;
bComp = 2;
aComp = 3;
stride = 3;
break;
case GL_BGR:
redIndex = 2;
greenIndex = 1;
blueIndex = 0;
alphaIndex = -1;
rComp = 2;
gComp = 1;
bComp = 0;
aComp = 3;
stride = 3;
break;
case GL_RGBA:
redIndex = 0;
greenIndex = 1;
blueIndex = 2;
alphaIndex = 3;
rComp = 0;
gComp = 1;
bComp = 2;
aComp = 3;
stride = 4;
break;
case GL_BGRA:
redIndex = 2;
greenIndex = 1;
blueIndex = 0;
alphaIndex = 3;
rComp = 2;
gComp = 1;
bComp = 0;
aComp = 3;
stride = 4;
break;
case GL_ABGR_EXT:
redIndex = 3;
greenIndex = 2;
blueIndex = 1;
alphaIndex = 0;
rComp = 3;
gComp = 2;
bComp = 1;
aComp = 0;
stride = 4;
break;
case GL_DU8DV8_ATI:
case GL_DUDV_ATI:
redIndex = 0;
greenIndex = 1;
blueIndex = -1;
alphaIndex = -1;
stride = 2;
break;
default:
_mesa_problem(NULL, "bad srcFormat %s in extract float data",
_mesa_lookup_enum_by_nr(srcFormat));
return;
}
#define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \
if ((INDEX) < 0) { \
GLuint i; \
for (i = 0; i < n; i++) { \
rgba[i][CHANNEL] = DEFAULT; \
} \
} \
else if (swapBytes) { \
const TYPE *s = (const TYPE *) src; \
GLuint i; \
for (i = 0; i < n; i++) { \
TYPE value = s[INDEX]; \
if (sizeof(TYPE) == 2) { \
SWAP2BYTE(value); \
} \
else if (sizeof(TYPE) == 4) { \
SWAP4BYTE(value); \
} \
rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \
s += stride; \
} \
} \
else { \
const TYPE *s = (const TYPE *) src; \
GLuint i; \
for (i = 0; i < n; i++) { \
rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \
s += stride; \
} \
}
switch (srcType) {
case GL_UNSIGNED_BYTE:
PROCESS(redIndex, RCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
PROCESS(greenIndex, GCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
PROCESS(blueIndex, BCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
PROCESS(alphaIndex, ACOMP, 1.0F, GLubyte, UBYTE_TO_FLOAT);
break;
case GL_BYTE:
PROCESS(redIndex, RCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
PROCESS(greenIndex, GCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
PROCESS(blueIndex, BCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
PROCESS(alphaIndex, ACOMP, 1.0F, GLbyte, BYTE_TO_FLOAT);
break;
case GL_UNSIGNED_SHORT:
PROCESS(redIndex, RCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
PROCESS(greenIndex, GCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
PROCESS(blueIndex, BCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
PROCESS(alphaIndex, ACOMP, 1.0F, GLushort, USHORT_TO_FLOAT);
break;
case GL_SHORT:
PROCESS(redIndex, RCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
PROCESS(greenIndex, GCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
PROCESS(blueIndex, BCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
PROCESS(alphaIndex, ACOMP, 1.0F, GLshort, SHORT_TO_FLOAT);
break;
case GL_UNSIGNED_INT:
PROCESS(redIndex, RCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
PROCESS(greenIndex, GCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
PROCESS(blueIndex, BCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
PROCESS(alphaIndex, ACOMP, 1.0F, GLuint, UINT_TO_FLOAT);
break;
case GL_INT:
PROCESS(redIndex, RCOMP, 0.0F, GLint, INT_TO_FLOAT);
PROCESS(greenIndex, GCOMP, 0.0F, GLint, INT_TO_FLOAT);
PROCESS(blueIndex, BCOMP, 0.0F, GLint, INT_TO_FLOAT);
PROCESS(alphaIndex, ACOMP, 1.0F, GLint, INT_TO_FLOAT);
break;
case GL_FLOAT:
PROCESS(redIndex, RCOMP, 0.0F, GLfloat, (GLfloat));
PROCESS(greenIndex, GCOMP, 0.0F, GLfloat, (GLfloat));
PROCESS(blueIndex, BCOMP, 0.0F, GLfloat, (GLfloat));
PROCESS(alphaIndex, ACOMP, 1.0F, GLfloat, (GLfloat));
break;
case GL_HALF_FLOAT_ARB:
PROCESS(redIndex, RCOMP, 0.0F, GLhalfARB, _mesa_half_to_float);
PROCESS(greenIndex, GCOMP, 0.0F, GLhalfARB, _mesa_half_to_float);
PROCESS(blueIndex, BCOMP, 0.0F, GLhalfARB, _mesa_half_to_float);
PROCESS(alphaIndex, ACOMP, 1.0F, GLhalfARB, _mesa_half_to_float);
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][rComp] = ((p >> 5) ) * (1.0F / 7.0F);
rgba[i][gComp] = ((p >> 2) & 0x7) * (1.0F / 7.0F);
rgba[i][bComp] = ((p ) & 0x3) * (1.0F / 3.0F);
rgba[i][aComp] = 1.0F;
}
}
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][rComp] = ((p ) & 0x7) * (1.0F / 7.0F);
rgba[i][gComp] = ((p >> 3) & 0x7) * (1.0F / 7.0F);
rgba[i][bComp] = ((p >> 6) ) * (1.0F / 3.0F);
rgba[i][aComp] = 1.0F;
}
}
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][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
rgba[i][bComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
rgba[i][aComp] = 1.0F;
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
rgba[i][bComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
rgba[i][aComp] = 1.0F;
}
}
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][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
rgba[i][bComp] = ((p >> 11) ) * (1.0F / 31.0F);
rgba[i][aComp] = 1.0F;
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
rgba[i][gComp] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
rgba[i][bComp] = ((p >> 11) ) * (1.0F / 31.0F);
rgba[i][aComp] = 1.0F;
}
}
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][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
}
}
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][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
}
}
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][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
}
}
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][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
}
}
else {
const GLushort *ussrc = (const GLushort *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLushort p = ussrc[i];
rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
}
}
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][rComp] = UBYTE_TO_FLOAT((p ) & 0xff);
rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24) );
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24) );
rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
rgba[i][aComp] = 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;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24) );
rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
rgba[i][aComp] = UBYTE_TO_FLOAT((p ) & 0xff);
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rComp] = UBYTE_TO_FLOAT((p ) & 0xff);
rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
rgba[i][aComp] = UBYTE_TO_FLOAT((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][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
}
}
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][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
}
}
else {
const GLuint *uisrc = (const GLuint *) src;
GLuint i;
for (i = 0; i < n; i ++) {
GLuint p = uisrc[i];
rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
}
}
break;
default:
_mesa_problem(NULL, "bad srcType in extract float data");
break;
}
}
/*
* Unpack a row of color image data from a client buffer according to
* the pixel unpacking parameters.
* Return GLchan 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_chan( GLcontext *ctx,
GLuint n, GLenum dstFormat, GLchan 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_RGB ||
dstFormat == GL_RGBA ||
dstFormat == GL_COLOR_INDEX);
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_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);
/* Try simple cases first */
if (transferOps == 0) {
if (srcType == CHAN_TYPE) {
if (dstFormat == GL_RGBA) {
if (srcFormat == GL_RGBA) {
_mesa_memcpy( dest, source, n * 4 * sizeof(GLchan) );
return;
}
else if (srcFormat == GL_RGB) {
GLuint i;
const GLchan *src = (const GLchan *) source;
GLchan *dst = dest;
for (i = 0; i < n; i++) {
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = CHAN_MAX;
src += 3;
dst += 4;
}
return;
}
}
else if (dstFormat == GL_RGB) {
if (srcFormat == GL_RGB) {
_mesa_memcpy( dest, source, n * 3 * sizeof(GLchan) );
return;
}
else if (srcFormat == GL_RGBA) {
GLuint i;
const GLchan *src = (const GLchan *) source;
GLchan *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);
_mesa_memcpy( dest, source, n * comps * sizeof(GLchan) );
return;
}
}
/*
* Common situation, loading 8bit RGBA/RGB source images
* into 16/32 bit destination. (OSMesa16/32)
*/
else if (srcType == GL_UNSIGNED_BYTE) {
if (dstFormat == GL_RGBA) {
if (srcFormat == GL_RGB) {
GLuint i;
const GLubyte *src = (const GLubyte *) source;
GLchan *dst = dest;
for (i = 0; i < n; i++) {
dst[0] = UBYTE_TO_CHAN(src[0]);
dst[1] = UBYTE_TO_CHAN(src[1]);
dst[2] = UBYTE_TO_CHAN(src[2]);
dst[3] = CHAN_MAX;
src += 3;
dst += 4;
}
return;
}
else if (srcFormat == GL_RGBA) {
GLuint i;
const GLubyte *src = (const GLubyte *) source;
GLchan *dst = dest;
for (i = 0; i < n; i++) {
dst[0] = UBYTE_TO_CHAN(src[0]);
dst[1] = UBYTE_TO_CHAN(src[1]);
dst[2] = UBYTE_TO_CHAN(src[2]);
dst[3] = UBYTE_TO_CHAN(src[3]);
src += 4;
dst += 4;
}
return;
}
}
else if (dstFormat == GL_RGB) {
if (srcFormat == GL_RGB) {
GLuint i;
const GLubyte *src = (const GLubyte *) source;
GLchan *dst = dest;
for (i = 0; i < n; i++) {
dst[0] = UBYTE_TO_CHAN(src[0]);
dst[1] = UBYTE_TO_CHAN(src[1]);
dst[2] = UBYTE_TO_CHAN(src[2]);
src += 3;
dst += 3;
}
return;
}
else if (srcFormat == GL_RGBA) {
GLuint i;
const GLubyte *src = (const GLubyte *) source;
GLchan *dst = dest;
for (i = 0; i < n; i++) {
dst[0] = UBYTE_TO_CHAN(src[0]);
dst[1] = UBYTE_TO_CHAN(src[1]);
dst[2] = UBYTE_TO_CHAN(src[2]);
src += 4;
dst += 3;
}
return;
}
}
}
}
/* general solution begins here */
{
GLint dstComponents;
GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
GLint dstLuminanceIndex, dstIntensityIndex;
GLfloat rgba[MAX_WIDTH][4];
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
*/
assert(n <= MAX_WIDTH);
if (srcFormat == GL_COLOR_INDEX) {
GLuint indexes[MAX_WIDTH];
extract_uint_indexes(n, indexes, srcFormat, srcType, source,
srcPacking);
if (dstFormat == GL_COLOR_INDEX) {
GLuint i;
_mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
/* convert to GLchan and return */
for (i = 0; i < n; i++) {
dest[i] = (GLchan) (indexes[i] & 0xff);
}
return;
}
else {
/* Convert indexes to RGBA */
if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
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);
}
else {
/* non-color index data */
extract_float_rgba(n, rgba, srcFormat, srcType, source,
srcPacking->SwapBytes);
}
/* Need to clamp if returning GLubytes or GLushorts */
#if CHAN_TYPE != GL_FLOAT
transferOps |= IMAGE_CLAMP_BIT;
#endif
if (transferOps) {
_mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
}
/* Now determine which color channels we need to produce.
* And determine the dest index (offset) within each color tuple.
*/
switch (dstFormat) {
case GL_ALPHA:
dstAlphaIndex = 0;
dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
dstLuminanceIndex = dstIntensityIndex = -1;
break;
case GL_LUMINANCE:
dstLuminanceIndex = 0;
dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
dstIntensityIndex = -1;
break;
case GL_LUMINANCE_ALPHA:
dstLuminanceIndex = 0;
dstAlphaIndex = 1;
dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
dstIntensityIndex = -1;
break;
case GL_INTENSITY:
dstIntensityIndex = 0;
dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
dstLuminanceIndex = -1;
break;
case GL_RGB:
dstRedIndex = 0;
dstGreenIndex = 1;
dstBlueIndex = 2;
dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
break;
case GL_RGBA:
dstRedIndex = 0;
dstGreenIndex = 1;
dstBlueIndex = 2;
dstAlphaIndex = 3;
dstLuminanceIndex = dstIntensityIndex = -1;
break;
default:
_mesa_problem(ctx, "bad dstFormat in _mesa_unpack_chan_span()");
return;
}
/* Now return the GLchan data in the requested dstFormat */
if (dstRedIndex >= 0) {
GLchan *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
CLAMPED_FLOAT_TO_CHAN(dst[dstRedIndex], rgba[i][RCOMP]);
dst += dstComponents;
}
}
if (dstGreenIndex >= 0) {
GLchan *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
CLAMPED_FLOAT_TO_CHAN(dst[dstGreenIndex], rgba[i][GCOMP]);
dst += dstComponents;
}
}
if (dstBlueIndex >= 0) {
GLchan *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
CLAMPED_FLOAT_TO_CHAN(dst[dstBlueIndex], rgba[i][BCOMP]);
dst += dstComponents;
}
}
if (dstAlphaIndex >= 0) {
GLchan *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
CLAMPED_FLOAT_TO_CHAN(dst[dstAlphaIndex], rgba[i][ACOMP]);
dst += dstComponents;
}
}
if (dstIntensityIndex >= 0) {
GLchan *dst = dest;
GLuint i;
assert(dstIntensityIndex == 0);
assert(dstComponents == 1);
for (i = 0; i < n; i++) {
/* Intensity comes from red channel */
CLAMPED_FLOAT_TO_CHAN(dst[i], rgba[i][RCOMP]);
}
}
if (dstLuminanceIndex >= 0) {
GLchan *dst = dest;
GLuint i;
assert(dstLuminanceIndex == 0);
for (i = 0; i < n; i++) {
/* Luminance comes from red channel */
CLAMPED_FLOAT_TO_CHAN(dst[0], rgba[i][RCOMP]);
dst += dstComponents;
}
}
}
}
/**
* Same as _mesa_unpack_color_span_chan(), but return GLfloat data
* instead of GLchan.
*/
void
_mesa_unpack_color_span_float( GLcontext *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_RGB ||
dstFormat == GL_RGBA ||
dstFormat == GL_COLOR_INDEX);
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_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);
/* general solution, no special cases, yet */
{
GLint dstComponents;
GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
GLint dstLuminanceIndex, dstIntensityIndex;
GLfloat rgba[MAX_WIDTH][4];
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
*/
assert(n <= MAX_WIDTH);
if (srcFormat == GL_COLOR_INDEX) {
GLuint indexes[MAX_WIDTH];
extract_uint_indexes(n, indexes, srcFormat, srcType, source,
srcPacking);
if (dstFormat == GL_COLOR_INDEX) {
GLuint i;
_mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
/* convert to GLchan and return */
for (i = 0; i < n; i++) {
dest[i] = (GLchan) (indexes[i] & 0xff);
}
return;
}
else {
/* Convert indexes to RGBA */
if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
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);
}
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);
}
/* Now determine which color channels we need to produce.
* And determine the dest index (offset) within each color tuple.
*/
switch (dstFormat) {
case GL_ALPHA:
dstAlphaIndex = 0;
dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
dstLuminanceIndex = dstIntensityIndex = -1;
break;
case GL_LUMINANCE:
dstLuminanceIndex = 0;
dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
dstIntensityIndex = -1;
break;
case GL_LUMINANCE_ALPHA:
dstLuminanceIndex = 0;
dstAlphaIndex = 1;
dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
dstIntensityIndex = -1;
break;
case GL_INTENSITY:
dstIntensityIndex = 0;
dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
dstLuminanceIndex = -1;
break;
case GL_RGB:
dstRedIndex = 0;
dstGreenIndex = 1;
dstBlueIndex = 2;
dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
break;
case GL_RGBA:
dstRedIndex = 0;
dstGreenIndex = 1;
dstBlueIndex = 2;
dstAlphaIndex = 3;
dstLuminanceIndex = dstIntensityIndex = -1;
break;
default:
_mesa_problem(ctx, "bad dstFormat in _mesa_unpack_color_span_float()");
return;
}
/* Now pack results in the requested dstFormat */
if (dstRedIndex >= 0) {
GLfloat *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[dstRedIndex] = rgba[i][RCOMP];
dst += dstComponents;
}
}
if (dstGreenIndex >= 0) {
GLfloat *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[dstGreenIndex] = rgba[i][GCOMP];
dst += dstComponents;
}
}
if (dstBlueIndex >= 0) {
GLfloat *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[dstBlueIndex] = rgba[i][BCOMP];
dst += dstComponents;
}
}
if (dstAlphaIndex >= 0) {
GLfloat *dst = dest;
GLuint i;
for (i = 0; i < n; i++) {
dst[dstAlphaIndex] = rgba[i][ACOMP];
dst += dstComponents;
}
}
if (dstIntensityIndex >= 0) {
GLfloat *dst = dest;
GLuint i;
assert(dstIntensityIndex == 0);
assert(dstComponents == 1);
for (i = 0; i < n; i++) {
/* Intensity comes from red channel */
dst[i] = rgba[i][RCOMP];
}
}
if (dstLuminanceIndex >= 0) {
GLfloat *dst = dest;
GLuint i;
assert(dstLuminanceIndex == 0);
for (i = 0; i < n; i++) {
/* Luminance comes from red channel */
dst[0] = rgba[i][RCOMP];
dst += dstComponents;
}
}
}
}
/**
* 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( GLcontext *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);
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;
GLfloat rgba[MAX_WIDTH][4];
GLbyte *dst = dest;
GLuint i;
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
*/
assert(n <= MAX_WIDTH);
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;
}
}
}
/*
* 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( const GLcontext *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) {
_mesa_memcpy(dest, source, n * sizeof(GLubyte));
}
else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
&& dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
_mesa_memcpy(dest, source, n * sizeof(GLuint));
}
else {
/*
* general solution
*/
GLuint indexes[MAX_WIDTH];
assert(n <= MAX_WIDTH);
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:
_mesa_memcpy(dest, indexes, n * sizeof(GLuint));
break;
default:
_mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
}
}
}
void
_mesa_pack_index_span( const GLcontext *ctx, GLuint n,
GLenum dstType, GLvoid *dest, const GLuint *source,
const struct gl_pixelstore_attrib *dstPacking,
GLbitfield transferOps )
{
GLuint indexes[MAX_WIDTH];
ASSERT(n <= MAX_WIDTH);
transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
/* make a copy of input */
_mesa_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");
}
}
/*
* 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( const GLcontext *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);
ASSERT(dstType == GL_UNSIGNED_BYTE ||
dstType == GL_UNSIGNED_SHORT ||
dstType == GL_UNSIGNED_INT);
/* 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) {
_mesa_memcpy(dest, source, n * sizeof(GLubyte));
}
else if (transferOps == 0 &&
!ctx->Pixel.MapStencilFlag &&
srcType == GL_UNSIGNED_INT &&
dstType == GL_UNSIGNED_INT &&
!srcPacking->SwapBytes) {
_mesa_memcpy(dest, source, n * sizeof(GLuint));
}
else {
/*
* general solution
*/
GLuint indexes[MAX_WIDTH];
assert(n <= MAX_WIDTH);
extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
srcPacking);
if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
/* shift and offset indexes */
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:
_mesa_memcpy(dest, indexes, n * sizeof(GLuint));
break;
default:
_mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
}
}
}
void
_mesa_pack_stencil_span( const GLcontext *ctx, GLuint n,
GLenum dstType, GLvoid *dest, const GLstencil *source,
const struct gl_pixelstore_attrib *dstPacking )
{
GLstencil stencil[MAX_WIDTH];
ASSERT(n <= MAX_WIDTH);
if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
ctx->Pixel.MapStencilFlag) {
/* make a copy of input */
_mesa_memcpy(stencil, source, n * sizeof(GLstencil));
_mesa_apply_stencil_transfer_ops(ctx, n, stencil);
source = stencil;
}
switch (dstType) {
case GL_UNSIGNED_BYTE:
if (sizeof(GLstencil) == 1) {
_mesa_memcpy( dest, source, n );
}
else {
GLubyte *dst = (GLubyte *) dest;
GLuint i;
for (i=0;i<n;i++) {
dst[i] = (GLubyte) source[i];
}
}
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");
}
}
#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( const GLcontext *ctx, GLuint n,
GLenum dstType, GLvoid *dest, GLuint depthMax,
GLenum srcType, const GLvoid *source,
const struct gl_pixelstore_attrib *srcPacking )
{
GLfloat depthTemp[MAX_WIDTH], *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 {
depthValues = depthTemp;
}
/* Convert incoming values to GLfloat. Some conversions will require
* clamping, below.
*/
switch (srcType) {
case GL_BYTE:
DEPTH_VALUES(GLbyte, BYTE_TO_FLOAT);
needClamp = GL_TRUE;
break;
case GL_UNSIGNED_BYTE:
DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
break;
case GL_SHORT:
DEPTH_VALUES(GLshort, SHORT_TO_FLOAT);
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;
}
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:
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()");
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] * (GLfloat) 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 {
ASSERT(dstType == GL_FLOAT);
/*ASSERT(depthMax == 1.0F);*/
}
}
/*
* Pack an array of depth values. The values are floats in [0,1].
*/
void
_mesa_pack_depth_span( const GLcontext *ctx, GLuint n, GLvoid *dest,
GLenum dstType, const GLfloat *depthSpan,
const struct gl_pixelstore_attrib *dstPacking )
{
GLfloat depthCopy[MAX_WIDTH];
ASSERT(n <= MAX_WIDTH);
if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
_mesa_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");
}
}
/**
* Pack depth and stencil values as GL_DEPTH_STENCIL/GL_UNSIGNED_INT_24_8.
*/
void
_mesa_pack_depth_stencil_span(const GLcontext *ctx, GLuint n, GLuint *dest,
const GLfloat *depthVals,
const GLstencil *stencilVals,
const struct gl_pixelstore_attrib *dstPacking)
{
GLfloat depthCopy[MAX_WIDTH];
GLstencil stencilCopy[MAX_WIDTH];
GLuint i;
ASSERT(n <= MAX_WIDTH);
if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
_mesa_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) {
_mesa_memcpy(stencilCopy, stencilVals, n * sizeof(GLstencil));
_mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
stencilVals = stencilCopy;
}
for (i = 0; i < n; i++) {
GLuint z = (GLuint) (depthVals[i] * 0xffffff);
dest[i] = (z << 8) | (stencilVals[i] & 0xff);
}
if (dstPacking->SwapBytes) {
_mesa_swap4(dest, n);
}
}
/**
* 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 *) _mesa_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 {
_mesa_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;
}
}
#endif /* _HAVE_FULL_GL */
/**
* Convert an array of RGBA colors from one datatype to another.
* NOTE: src may equal dst. In that case, we use a temporary buffer.
*/
void
_mesa_convert_colors(GLenum srcType, const GLvoid *src,
GLenum dstType, GLvoid *dst,
GLuint count, const GLubyte mask[])
{
GLuint tempBuffer[MAX_WIDTH][4];
const GLboolean useTemp = (src == dst);
ASSERT(srcType != dstType);
switch (srcType) {
case GL_UNSIGNED_BYTE:
if (dstType == GL_UNSIGNED_SHORT) {
const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src;
GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst);
GLuint i;
for (i = 0; i < count; i++) {
if (!mask || mask[i]) {
dst2[i][RCOMP] = UBYTE_TO_USHORT(src1[i][RCOMP]);
dst2[i][GCOMP] = UBYTE_TO_USHORT(src1[i][GCOMP]);
dst2[i][BCOMP] = UBYTE_TO_USHORT(src1[i][BCOMP]);
dst2[i][ACOMP] = UBYTE_TO_USHORT(src1[i][ACOMP]);
}
}
if (useTemp)
_mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort));
}
else {
const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src;
GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst);
GLuint i;
ASSERT(dstType == GL_FLOAT);
for (i = 0; i < count; i++) {
if (!mask || mask[i]) {
dst4[i][RCOMP] = UBYTE_TO_FLOAT(src1[i][RCOMP]);
dst4[i][GCOMP] = UBYTE_TO_FLOAT(src1[i][GCOMP]);
dst4[i][BCOMP] = UBYTE_TO_FLOAT(src1[i][BCOMP]);
dst4[i][ACOMP] = UBYTE_TO_FLOAT(src1[i][ACOMP]);
}
}
if (useTemp)
_mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat));
}
break;
case GL_UNSIGNED_SHORT:
if (dstType == GL_UNSIGNED_BYTE) {
const GLushort (*src2)[4] = (const GLushort (*)[4]) src;
GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst);
GLuint i;
for (i = 0; i < count; i++) {
if (!mask || mask[i]) {
dst1[i][RCOMP] = USHORT_TO_UBYTE(src2[i][RCOMP]);
dst1[i][GCOMP] = USHORT_TO_UBYTE(src2[i][GCOMP]);
dst1[i][BCOMP] = USHORT_TO_UBYTE(src2[i][BCOMP]);
dst1[i][ACOMP] = USHORT_TO_UBYTE(src2[i][ACOMP]);
}
}
if (useTemp)
_mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte));
}
else {
const GLushort (*src2)[4] = (const GLushort (*)[4]) src;
GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst);
GLuint i;
ASSERT(dstType == GL_FLOAT);
for (i = 0; i < count; i++) {
if (!mask || mask[i]) {
dst4[i][RCOMP] = USHORT_TO_FLOAT(src2[i][RCOMP]);
dst4[i][GCOMP] = USHORT_TO_FLOAT(src2[i][GCOMP]);
dst4[i][BCOMP] = USHORT_TO_FLOAT(src2[i][BCOMP]);
dst4[i][ACOMP] = USHORT_TO_FLOAT(src2[i][ACOMP]);
}
}
if (useTemp)
_mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat));
}
break;
case GL_FLOAT:
if (dstType == GL_UNSIGNED_BYTE) {
const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src;
GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst);
GLuint i;
for (i = 0; i < count; i++) {
if (!mask || mask[i]) {
UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][RCOMP], src4[i][RCOMP]);
UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][GCOMP], src4[i][GCOMP]);
UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][BCOMP], src4[i][BCOMP]);
UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][ACOMP], src4[i][ACOMP]);
}
}
if (useTemp)
_mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte));
}
else {
const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src;
GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst);
GLuint i;
ASSERT(dstType == GL_UNSIGNED_SHORT);
for (i = 0; i < count; i++) {
if (!mask || mask[i]) {
UNCLAMPED_FLOAT_TO_USHORT(dst2[i][RCOMP], src4[i][RCOMP]);
UNCLAMPED_FLOAT_TO_USHORT(dst2[i][GCOMP], src4[i][GCOMP]);
UNCLAMPED_FLOAT_TO_USHORT(dst2[i][BCOMP], src4[i][BCOMP]);
UNCLAMPED_FLOAT_TO_USHORT(dst2[i][ACOMP], src4[i][ACOMP]);
}
}
if (useTemp)
_mesa_memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort));
}
break;
default:
_mesa_problem(NULL, "Invalid datatype in _mesa_convert_colors");
}
}
/**
* Perform basic clipping for glDrawPixels. The image's position and size
* and the unpack SkipPixels and SkipRows are adjusted so that the image
* region is entirely within the window and scissor bounds.
* NOTE: this will only work when glPixelZoom is (1, 1) or (1, -1).
* If Pixel.ZoomY is -1, *destY will be changed to be the first row which
* we'll actually write. Beforehand, *destY-1 is the first drawing row.
*
* \return GL_TRUE if image is ready for drawing or
* GL_FALSE if image was completely clipped away (draw nothing)
*/
GLboolean
_mesa_clip_drawpixels(const GLcontext *ctx,
GLint *destX, GLint *destY,
GLsizei *width, GLsizei *height,
struct gl_pixelstore_attrib *unpack)
{
const GLframebuffer *buffer = ctx->DrawBuffer;
if (unpack->RowLength == 0) {
unpack->RowLength = *width;
}
ASSERT(ctx->Pixel.ZoomX == 1.0F);
ASSERT(ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F);
/* left clipping */
if (*destX < buffer->_Xmin) {
unpack->SkipPixels += (buffer->_Xmin - *destX);
*width -= (buffer->_Xmin - *destX);
*destX = buffer->_Xmin;
}
/* right clipping */
if (*destX + *width > buffer->_Xmax)
*width -= (*destX + *width - buffer->_Xmax);
if (*width <= 0)
return GL_FALSE;
if (ctx->Pixel.ZoomY == 1.0F) {
/* bottom clipping */
if (*destY < buffer->_Ymin) {
unpack->SkipRows += (buffer->_Ymin - *destY);
*height -= (buffer->_Ymin - *destY);
*destY = buffer->_Ymin;
}
/* top clipping */
if (*destY + *height > buffer->_Ymax)
*height -= (*destY + *height - buffer->_Ymax);
}
else { /* upside down */
/* top clipping */
if (*destY > buffer->_Ymax) {
unpack->SkipRows += (*destY - buffer->_Ymax);
*height -= (*destY - buffer->_Ymax);
*destY = buffer->_Ymax;
}
/* bottom clipping */
if (*destY - *height < buffer->_Ymin)
*height -= (buffer->_Ymin - (*destY - *height));
/* adjust destY so it's the first row to write to */
(*destY)--;
}
if (*height <= 0)
return GL_FALSE;
return GL_TRUE;
}
/**
* Perform clipping for glReadPixels. The image's window position
* and size, and the pack skipPixels, skipRows and rowLength are adjusted
* so that the image region is entirely within the window bounds.
* Note: this is different from _mesa_clip_drawpixels() in that the
* scissor box is ignored, and we use the bounds of the current readbuffer
* surface.
*
* \return GL_TRUE if image is ready for drawing or
* GL_FALSE if image was completely clipped away (draw nothing)
*/
GLboolean
_mesa_clip_readpixels(const GLcontext *ctx,
GLint *srcX, GLint *srcY,
GLsizei *width, GLsizei *height,
struct gl_pixelstore_attrib *pack)
{
const GLframebuffer *buffer = ctx->ReadBuffer;
if (pack->RowLength == 0) {
pack->RowLength = *width;
}
/* left clipping */
if (*srcX < 0) {
pack->SkipPixels += (0 - *srcX);
*width -= (0 - *srcX);
*srcX = 0;
}
/* right clipping */
if (*srcX + *width > (GLsizei) buffer->Width)
*width -= (*srcX + *width - buffer->Width);
if (*width <= 0)
return GL_FALSE;
/* bottom clipping */
if (*srcY < 0) {
pack->SkipRows += (0 - *srcY);
*height -= (0 - *srcY);
*srcY = 0;
}
/* top clipping */
if (*srcY + *height > (GLsizei) buffer->Height)
*height -= (*srcY + *height - buffer->Height);
if (*height <= 0)
return GL_FALSE;
return GL_TRUE;
}
/**
* Do clipping for a glCopyTexSubImage call.
* The framebuffer source region might extend outside the framebuffer
* bounds. Clip the source region against the framebuffer bounds and
* adjust the texture/dest position and size accordingly.
*
* \return GL_FALSE if region is totally clipped, GL_TRUE otherwise.
*/
GLboolean
_mesa_clip_copytexsubimage(const GLcontext *ctx,
GLint *destX, GLint *destY,
GLint *srcX, GLint *srcY,
GLsizei *width, GLsizei *height)
{
const struct gl_framebuffer *fb = ctx->ReadBuffer;
const GLint srcX0 = *srcX, srcY0 = *srcY;
if (_mesa_clip_to_region(0, 0, fb->Width, fb->Height,
srcX, srcY, width, height)) {
*destX = *destX + *srcX - srcX0;
*destY = *destY + *srcY - srcY0;
return GL_TRUE;
}
else {
return GL_FALSE;
}
}
/**
* Clip the rectangle defined by (x, y, width, height) against the bounds
* specified by [xmin, xmax) and [ymin, ymax).
* \return GL_FALSE if rect is totally clipped, GL_TRUE otherwise.
*/
GLboolean
_mesa_clip_to_region(GLint xmin, GLint ymin,
GLint xmax, GLint ymax,
GLint *x, GLint *y,
GLsizei *width, GLsizei *height )
{
/* left clipping */
if (*x < xmin) {
*width -= (xmin - *x);
*x = xmin;
}
/* right clipping */
if (*x + *width > xmax)
*width -= (*x + *width - xmax);
if (*width <= 0)
return GL_FALSE;
/* bottom (or top) clipping */
if (*y < ymin) {
*height -= (ymin - *y);
*y = ymin;
}
/* top (or bottom) clipping */
if (*y + *height > ymax)
*height -= (*y + *height - ymax);
if (*height <= 0)
return GL_FALSE;
return GL_TRUE;
}
/**
* Clip dst coords against Xmax (or Ymax).
*/
static INLINE void
clip_right_or_top(GLint *srcX0, GLint *srcX1,
GLint *dstX0, GLint *dstX1,
GLint maxValue)
{
GLfloat t, bias;
if (*dstX1 > maxValue) {
/* X1 outside right edge */
ASSERT(*dstX0 < maxValue); /* X0 should be inside right edge */
t = (GLfloat) (maxValue - *dstX0) / (GLfloat) (*dstX1 - *dstX0);
/* chop off [t, 1] part */
ASSERT(t >= 0.0 && t <= 1.0);
*dstX1 = maxValue;
bias = (*srcX0 < *srcX1) ? 0.5 : -0.5;
*srcX1 = *srcX0 + (GLint) (t * (*srcX1 - *srcX0) + bias);
}
else if (*dstX0 > maxValue) {
/* X0 outside right edge */
ASSERT(*dstX1 < maxValue); /* X1 should be inside right edge */
t = (GLfloat) (maxValue - *dstX1) / (GLfloat) (*dstX0 - *dstX1);
/* chop off [t, 1] part */
ASSERT(t >= 0.0 && t <= 1.0);
*dstX0 = maxValue;
bias = (*srcX0 < *srcX1) ? -0.5 : 0.5;
*srcX0 = *srcX1 + (GLint) (t * (*srcX0 - *srcX1) + bias);
}
}
/**
* Clip dst coords against Xmin (or Ymin).
*/
static INLINE void
clip_left_or_bottom(GLint *srcX0, GLint *srcX1,
GLint *dstX0, GLint *dstX1,
GLint minValue)
{
GLfloat t, bias;
if (*dstX0 < minValue) {
/* X0 outside left edge */
ASSERT(*dstX1 > minValue); /* X1 should be inside left edge */
t = (GLfloat) (minValue - *dstX0) / (GLfloat) (*dstX1 - *dstX0);
/* chop off [0, t] part */
ASSERT(t >= 0.0 && t <= 1.0);
*dstX0 = minValue;
bias = (*srcX0 < *srcX1) ? 0.5 : -0.5; /* flipped??? */
*srcX0 = *srcX0 + (GLint) (t * (*srcX1 - *srcX0) + bias);
}
else if (*dstX1 < minValue) {
/* X1 outside left edge */
ASSERT(*dstX0 > minValue); /* X0 should be inside left edge */
t = (GLfloat) (minValue - *dstX1) / (GLfloat) (*dstX0 - *dstX1);
/* chop off [0, t] part */
ASSERT(t >= 0.0 && t <= 1.0);
*dstX1 = minValue;
bias = (*srcX0 < *srcX1) ? 0.5 : -0.5;
*srcX1 = *srcX1 + (GLint) (t * (*srcX0 - *srcX1) + bias);
}
}
/**
* Do clipping of blit src/dest rectangles.
* The dest rect is clipped against both the buffer bounds and scissor bounds.
* The src rect is just clipped against the buffer bounds.
*
* When either the src or dest rect is clipped, the other is also clipped
* proportionately!
*
* Note that X0 need not be less than X1 (same for Y) for either the source
* and dest rects. That makes the clipping a little trickier.
*
* \return GL_TRUE if anything is left to draw, GL_FALSE if totally clipped
*/
GLboolean
_mesa_clip_blit(GLcontext *ctx,
GLint *srcX0, GLint *srcY0, GLint *srcX1, GLint *srcY1,
GLint *dstX0, GLint *dstY0, GLint *dstX1, GLint *dstY1)
{
const GLint srcXmin = 0;
const GLint srcXmax = ctx->ReadBuffer->Width;
const GLint srcYmin = 0;
const GLint srcYmax = ctx->ReadBuffer->Height;
/* these include scissor bounds */
const GLint dstXmin = ctx->DrawBuffer->_Xmin;
const GLint dstXmax = ctx->DrawBuffer->_Xmax;
const GLint dstYmin = ctx->DrawBuffer->_Ymin;
const GLint dstYmax = ctx->DrawBuffer->_Ymax;
/*
printf("PreClipX: src: %d .. %d dst: %d .. %d\n",
*srcX0, *srcX1, *dstX0, *dstX1);
printf("PreClipY: src: %d .. %d dst: %d .. %d\n",
*srcY0, *srcY1, *dstY0, *dstY1);
*/
/* trivial rejection tests */
if (*dstX0 == *dstX1)
return GL_FALSE; /* no width */
if (*dstX0 <= dstXmin && *dstX1 <= dstXmin)
return GL_FALSE; /* totally out (left) of bounds */
if (*dstX0 >= dstXmax && *dstX1 >= dstXmax)
return GL_FALSE; /* totally out (right) of bounds */
if (*dstY0 == *dstY1)
return GL_FALSE;
if (*dstY0 <= dstYmin && *dstY1 <= dstYmin)
return GL_FALSE;
if (*dstY0 >= dstYmax && *dstY1 >= dstYmax)
return GL_FALSE;
if (*srcX0 == *srcX1)
return GL_FALSE;
if (*srcX0 <= srcXmin && *srcX1 <= srcXmin)
return GL_FALSE;
if (*srcX0 >= srcXmax && *srcX1 >= srcXmax)
return GL_FALSE;
if (*srcY0 == *srcY1)
return GL_FALSE;
if (*srcY0 <= srcYmin && *srcY1 <= srcYmin)
return GL_FALSE;
if (*srcY0 >= srcYmax && *srcY1 >= srcYmax)
return GL_FALSE;
/*
* dest clip
*/
clip_right_or_top(srcX0, srcX1, dstX0, dstX1, dstXmax);
clip_right_or_top(srcY0, srcY1, dstY0, dstY1, dstYmax);
clip_left_or_bottom(srcX0, srcX1, dstX0, dstX1, dstXmin);
clip_left_or_bottom(srcY0, srcY1, dstY0, dstY1, dstYmin);
/*
* src clip (just swap src/dst values from above)
*/
clip_right_or_top(dstX0, dstX1, srcX0, srcX1, srcXmax);
clip_right_or_top(dstY0, dstY1, srcY0, srcY1, srcYmax);
clip_left_or_bottom(dstX0, dstX1, srcX0, srcX1, srcXmin);
clip_left_or_bottom(dstY0, dstY1, srcY0, srcY1, srcYmin);
/*
printf("PostClipX: src: %d .. %d dst: %d .. %d\n",
*srcX0, *srcX1, *dstX0, *dstX1);
printf("PostClipY: src: %d .. %d dst: %d .. %d\n",
*srcY0, *srcY1, *dstY0, *dstY1);
*/
ASSERT(*dstX0 >= dstXmin);
ASSERT(*dstX0 <= dstXmax);
ASSERT(*dstX1 >= dstXmin);
ASSERT(*dstX1 <= dstXmax);
ASSERT(*dstY0 >= dstYmin);
ASSERT(*dstY0 <= dstYmax);
ASSERT(*dstY1 >= dstYmin);
ASSERT(*dstY1 <= dstYmax);
ASSERT(*srcX0 >= srcXmin);
ASSERT(*srcX0 <= srcXmax);
ASSERT(*srcX1 >= srcXmin);
ASSERT(*srcX1 <= srcXmax);
ASSERT(*srcY0 >= srcYmin);
ASSERT(*srcY0 <= srcYmax);
ASSERT(*srcY1 >= srcYmin);
ASSERT(*srcY1 <= srcYmax);
return GL_TRUE;
}