#endif
+#include "errors.h"
#include "glheader.h"
-#include "colormac.h"
#include "enums.h"
#include "image.h"
-#include "imports.h"
+
#include "macros.h"
#include "mtypes.h"
#include "pack.h"
#include "pixeltransfer.h"
-#include "imports.h"
+
#include "glformats.h"
#include "format_utils.h"
#include "format_pack.h"
if (!source)
return;
- width_in_bytes = CEILING( width, 8 );
+ width_in_bytes = DIV_ROUND_UP( width, 8 );
src = source;
for (row = 0; row < height; row++) {
GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dest,
GLenum srcFormat, GLenum srcType, const GLvoid *src,
const struct gl_pixelstore_attrib *unpack )
{
- ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX);
+ assert(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX);
- ASSERT(srcType == GL_BITMAP ||
+ assert(srcType == GL_BITMAP ||
srcType == GL_UNSIGNED_BYTE ||
srcType == GL_BYTE ||
srcType == GL_UNSIGNED_SHORT ||
srcType == GL_INT ||
srcType == GL_UNSIGNED_INT_24_8_EXT ||
srcType == GL_HALF_FLOAT_ARB ||
+ srcType == GL_HALF_FLOAT_OES ||
srcType == GL_FLOAT ||
srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
}
break;
case GL_HALF_FLOAT_ARB:
+ case GL_HALF_FLOAT_OES:
{
GLuint i;
const GLhalfARB *s = (const GLhalfARB *) src;
break;
default:
- _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
- return;
- }
-}
-
-
-static inline GLuint
-clamp_float_to_uint(GLfloat f)
-{
- return f < 0.0F ? 0 : F_TO_I(f);
-}
-
-
-static inline GLuint
-clamp_half_to_uint(GLhalfARB h)
-{
- GLfloat f = _mesa_half_to_float(h);
- return f < 0.0F ? 0 : F_TO_I(f);
-}
-
-
-/*
- * Unpack a row of color index data from a client buffer according to
- * the pixel unpacking parameters.
- * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
- *
- * Args: ctx - the context
- * n - number of pixels
- * dstType - destination data type
- * dest - destination array
- * srcType - source pixel type
- * source - source data pointer
- * srcPacking - pixel unpacking parameters
- * transferOps - the pixel transfer operations to apply
- */
-void
-_mesa_unpack_index_span( struct gl_context *ctx, GLuint n,
- GLenum dstType, GLvoid *dest,
- GLenum srcType, const GLvoid *source,
- const struct gl_pixelstore_attrib *srcPacking,
- GLbitfield transferOps )
-{
- ASSERT(srcType == GL_BITMAP ||
- srcType == GL_UNSIGNED_BYTE ||
- srcType == GL_BYTE ||
- srcType == GL_UNSIGNED_SHORT ||
- srcType == GL_SHORT ||
- srcType == GL_UNSIGNED_INT ||
- srcType == GL_INT ||
- srcType == GL_HALF_FLOAT_ARB ||
- srcType == GL_FLOAT);
-
- ASSERT(dstType == GL_UNSIGNED_BYTE ||
- dstType == GL_UNSIGNED_SHORT ||
- dstType == GL_UNSIGNED_INT);
-
-
- transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
-
- /*
- * Try simple cases first
- */
- if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
- && dstType == GL_UNSIGNED_BYTE) {
- memcpy(dest, source, n * sizeof(GLubyte));
- }
- else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
- && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
- memcpy(dest, source, n * sizeof(GLuint));
- }
- else {
- /*
- * general solution
- */
- GLuint *indexes = malloc(n * sizeof(GLuint));
-
- if (!indexes) {
- _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
- return;
- }
-
- extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
- srcPacking);
-
- if (transferOps)
- _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
-
- /* convert to dest type */
- switch (dstType) {
- case GL_UNSIGNED_BYTE:
- {
- GLubyte *dst = (GLubyte *) dest;
- GLuint i;
- for (i = 0; i < n; i++) {
- dst[i] = (GLubyte) (indexes[i] & 0xff);
- }
- }
- break;
- case GL_UNSIGNED_SHORT:
- {
- GLuint *dst = (GLuint *) dest;
- GLuint i;
- for (i = 0; i < n; i++) {
- dst[i] = (GLushort) (indexes[i] & 0xffff);
- }
- }
- break;
- case GL_UNSIGNED_INT:
- memcpy(dest, indexes, n * sizeof(GLuint));
- break;
- default:
- _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
- }
-
- free(indexes);
- }
-}
-
-
-void
-_mesa_pack_index_span( struct gl_context *ctx, GLuint n,
- GLenum dstType, GLvoid *dest, const GLuint *source,
- const struct gl_pixelstore_attrib *dstPacking,
- GLbitfield transferOps )
-{
- GLuint *indexes = malloc(n * sizeof(GLuint));
-
- if (!indexes) {
- _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
- return;
- }
-
- transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
-
- if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
- /* make a copy of input */
- memcpy(indexes, source, n * sizeof(GLuint));
- _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
- source = indexes;
- }
-
- switch (dstType) {
- case GL_UNSIGNED_BYTE:
- {
- GLubyte *dst = (GLubyte *) dest;
- GLuint i;
- for (i = 0; i < n; i++) {
- *dst++ = (GLubyte) source[i];
- }
- }
- break;
- case GL_BYTE:
- {
- GLbyte *dst = (GLbyte *) dest;
- GLuint i;
- for (i = 0; i < n; i++) {
- dst[i] = (GLbyte) source[i];
- }
- }
- break;
- case GL_UNSIGNED_SHORT:
- {
- GLushort *dst = (GLushort *) dest;
- GLuint i;
- for (i = 0; i < n; i++) {
- dst[i] = (GLushort) source[i];
- }
- if (dstPacking->SwapBytes) {
- _mesa_swap2( (GLushort *) dst, n );
- }
- }
- break;
- case GL_SHORT:
- {
- GLshort *dst = (GLshort *) dest;
- GLuint i;
- for (i = 0; i < n; i++) {
- dst[i] = (GLshort) source[i];
- }
- if (dstPacking->SwapBytes) {
- _mesa_swap2( (GLushort *) dst, n );
- }
- }
- break;
- case GL_UNSIGNED_INT:
- {
- GLuint *dst = (GLuint *) dest;
- GLuint i;
- for (i = 0; i < n; i++) {
- dst[i] = (GLuint) source[i];
- }
- if (dstPacking->SwapBytes) {
- _mesa_swap4( (GLuint *) dst, n );
- }
- }
- break;
- case GL_INT:
- {
- GLint *dst = (GLint *) dest;
- GLuint i;
- for (i = 0; i < n; i++) {
- dst[i] = (GLint) source[i];
- }
- if (dstPacking->SwapBytes) {
- _mesa_swap4( (GLuint *) dst, n );
- }
- }
- break;
- case GL_FLOAT:
- {
- GLfloat *dst = (GLfloat *) dest;
- GLuint i;
- for (i = 0; i < n; i++) {
- dst[i] = (GLfloat) source[i];
- }
- if (dstPacking->SwapBytes) {
- _mesa_swap4( (GLuint *) dst, n );
- }
- }
- break;
- case GL_HALF_FLOAT_ARB:
- {
- GLhalfARB *dst = (GLhalfARB *) dest;
- GLuint i;
- for (i = 0; i < n; i++) {
- dst[i] = _mesa_float_to_half((GLfloat) source[i]);
- }
- if (dstPacking->SwapBytes) {
- _mesa_swap2( (GLushort *) dst, n );
- }
- }
- break;
- default:
- _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
+ unreachable("bad srcType in extract_uint_indexes");
}
-
- free(indexes);
}
const struct gl_pixelstore_attrib *srcPacking,
GLbitfield transferOps )
{
- ASSERT(srcType == GL_BITMAP ||
+ assert(srcType == GL_BITMAP ||
srcType == GL_UNSIGNED_BYTE ||
srcType == GL_BYTE ||
srcType == GL_UNSIGNED_SHORT ||
srcType == GL_INT ||
srcType == GL_UNSIGNED_INT_24_8_EXT ||
srcType == GL_HALF_FLOAT_ARB ||
+ srcType == GL_HALF_FLOAT_OES ||
srcType == GL_FLOAT ||
srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
- ASSERT(dstType == GL_UNSIGNED_BYTE ||
+ assert(dstType == GL_UNSIGNED_BYTE ||
dstType == GL_UNSIGNED_SHORT ||
dstType == GL_UNSIGNED_INT ||
dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
}
break;
default:
- _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
+ unreachable("bad dstType in _mesa_unpack_stencil_span");
}
free(indexes);
}
break;
case GL_HALF_FLOAT_ARB:
+ case GL_HALF_FLOAT_OES:
{
GLhalfARB *dst = (GLhalfARB *) dest;
GLuint i;
}
break;
default:
- _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
+ unreachable("bad type in _mesa_pack_index_span");
}
free(stencil);
* 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 (ctx->Pixel.DepthScale == 1.0F && ctx->Pixel.DepthBias == 0.0F) {
if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {
const GLuint *src = (const GLuint *) source;
GLushort *dst = (GLushort *) dest;
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) {
+ ctx->Pixel.DepthScale == 1.0F &&
+ ctx->Pixel.DepthBias == 0.0F) {
const GLuint *src = (const GLuint *) source;
GLuint *zValues = (GLuint *) dest;
GLuint i;
needClamp = GL_TRUE;
break;
case GL_HALF_FLOAT_ARB:
+ case GL_HALF_FLOAT_OES:
{
GLuint i;
const GLhalfARB *src = (const GLhalfARB *) source;
{
const GLfloat scale = ctx->Pixel.DepthScale;
const GLfloat bias = ctx->Pixel.DepthBias;
- if (scale != 1.0 || bias != 0.0) {
+ if (scale != 1.0F || bias != 0.0F) {
GLuint i;
for (i = 0; i < n; i++) {
depthValues[i] = depthValues[i] * scale + bias;
if (needClamp) {
GLuint i;
for (i = 0; i < n; i++) {
- depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);
+ depthValues[i] = CLAMP(depthValues[i], 0.0F, 1.0F);
}
}
else if (dstType == GL_UNSIGNED_SHORT) {
GLushort *zValues = (GLushort *) dest;
GLuint i;
- ASSERT(depthMax <= 0xffff);
+ assert(depthMax <= 0xffff);
for (i = 0; i < n; i++) {
zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);
}
}
}
else {
- ASSERT(0);
+ assert(0);
}
free(depthTemp);
return;
}
- if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
+ if (ctx->Pixel.DepthScale != 1.0F || ctx->Pixel.DepthBias != 0.0F) {
memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
_mesa_scale_and_bias_depth(ctx, n, depthCopy);
depthSpan = depthCopy;
}
}
break;
+ case GL_UNSIGNED_INT_24_8:
+ {
+ const GLdouble scale = (GLdouble) 0xffffff;
+ GLuint *dst = (GLuint *) dest;
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ GLuint z = (GLuint) (depthSpan[i] * scale);
+ assert(z <= 0xffffff);
+ dst[i] = (z << 8);
+ }
+ if (dstPacking->SwapBytes) {
+ _mesa_swap4( (GLuint *) dst, n );
+ }
+ break;
+ }
case GL_UNSIGNED_INT:
{
GLuint *dst = (GLuint *) dest;
}
break;
case GL_HALF_FLOAT_ARB:
+ case GL_HALF_FLOAT_OES:
{
GLhalfARB *dst = (GLhalfARB *) dest;
GLuint i;
}
break;
default:
- _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
+ unreachable("bad type in _mesa_pack_depth_span()");
}
free(depthCopy);
return;
}
- if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
+ if (ctx->Pixel.DepthScale != 1.0F || ctx->Pixel.DepthBias != 0.0F) {
memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
_mesa_scale_and_bias_depth(ctx, n, depthCopy);
depthVals = depthCopy;
for (i = 0; i < width; i++) {
if (*s & srcMask) {
*d |= dstMask;
- }
+ }
if (srcMask == 128) {
srcMask = 1;
s++;
}
else {
dstMask = dstMask >> 1;
- }
+ }
}
}
}
}
}
-
-
-/**
- * If we unpack colors from a luminance surface, we'll get pixel colors
- * such as (l, l, l, a).
- * When we call _mesa_pack_rgba_span_float(format=GL_LUMINANCE), that
- * function will compute L=R+G+B before packing. The net effect is we'll
- * accidentally store luminance values = 3*l.
- * This function compensates for that by converting (aka rebasing) (l,l,l,a)
- * to be (l,0,0,a).
- * It's a similar story for other formats such as LUMINANCE_ALPHA, ALPHA
- * and INTENSITY.
- *
- * Finally, we also need to do this when the actual surface format does
- * not match the logical surface format. For example, suppose the user
- * requests a GL_LUMINANCE texture but the driver stores it as RGBA.
- * Again, we'll get pixel values like (l,l,l,a).
- */
-void
-_mesa_rebase_rgba_float(GLuint n, GLfloat rgba[][4], GLenum baseFormat)
-{
- GLuint i;
-
- switch (baseFormat) {
- case GL_ALPHA:
- for (i = 0; i < n; i++) {
- rgba[i][RCOMP] = 0.0F;
- rgba[i][GCOMP] = 0.0F;
- rgba[i][BCOMP] = 0.0F;
- }
- break;
- case GL_INTENSITY:
- /* fall-through */
- case GL_LUMINANCE:
- for (i = 0; i < n; i++) {
- rgba[i][GCOMP] = 0.0F;
- rgba[i][BCOMP] = 0.0F;
- rgba[i][ACOMP] = 1.0F;
- }
- break;
- case GL_LUMINANCE_ALPHA:
- for (i = 0; i < n; i++) {
- rgba[i][GCOMP] = 0.0F;
- rgba[i][BCOMP] = 0.0F;
- }
- break;
- case GL_RGB:
- for (i = 0; i < n; i++) {
- rgba[i][ACOMP] = 1.0F;
- }
- break;
- case GL_RG:
- for (i = 0; i < n; i++) {
- rgba[i][BCOMP] = 0.0F;
- rgba[i][ACOMP] = 1.0F;
- }
- break;
- case GL_RED:
- for (i = 0; i < n; i++) {
- rgba[i][GCOMP] = 0.0F;
- rgba[i][BCOMP] = 0.0F;
- rgba[i][ACOMP] = 1.0F;
- }
- break;
-
- default:
- /* no-op */
- ;
- }
-}
-
-
-/**
- * As above, but GLuint components.
- */
-void
-_mesa_rebase_rgba_uint(GLuint n, GLuint rgba[][4], GLenum baseFormat)
-{
- GLuint i;
-
- switch (baseFormat) {
- case GL_ALPHA:
- for (i = 0; i < n; i++) {
- rgba[i][RCOMP] = 0;
- rgba[i][GCOMP] = 0;
- rgba[i][BCOMP] = 0;
- }
- break;
- case GL_INTENSITY:
- /* fall-through */
- case GL_LUMINANCE:
- for (i = 0; i < n; i++) {
- rgba[i][GCOMP] = 0;
- rgba[i][BCOMP] = 0;
- rgba[i][ACOMP] = 1;
- }
- break;
- case GL_LUMINANCE_ALPHA:
- for (i = 0; i < n; i++) {
- rgba[i][GCOMP] = 0;
- rgba[i][BCOMP] = 0;
- }
- break;
- case GL_RGB:
- for (i = 0; i < n; i++) {
- rgba[i][ACOMP] = 1;
- }
- break;
- case GL_RG:
- for (i = 0; i < n; i++) {
- rgba[i][BCOMP] = 0;
- rgba[i][ACOMP] = 1;
- }
- break;
- case GL_RED:
- for (i = 0; i < n; i++) {
- rgba[i][GCOMP] = 0;
- rgba[i][BCOMP] = 0;
- rgba[i][ACOMP] = 1;
- }
- default:
- /* no-op */
- ;
- }
-}
-
void
_mesa_pack_luminance_from_rgba_float(GLuint n, GLfloat rgba[][4],
GLvoid *dstAddr, GLenum dst_format,
GLenum dst_format,
GLenum dst_type)
{
- assert(dst_format == GL_LUMINANCE_INTEGER_EXT ||
- dst_format == GL_LUMINANCE_ALPHA_INTEGER_EXT);
-
int i;
int64_t lum64;
int32_t lum32, alpha;
bool dst_is_signed;
int dst_bits;
+ assert(dst_format == GL_LUMINANCE_INTEGER_EXT ||
+ dst_format == GL_LUMINANCE_ALPHA_INTEGER_EXT);
+
/* We first compute luminance values as a 64-bit addition of the
* 32-bit R,G,B components, then we clamp the result to the dst type size.
*
case GL_UNSIGNED_BYTE: {
GLbyte *dst = (GLbyte *) dstAddr;
dst[i] = lum32;
+ break;
}
- break;
case GL_SHORT:
case GL_UNSIGNED_SHORT: {
GLshort *dst = (GLshort *) dstAddr;
dst[i] = lum32;
+ break;
}
- break;
case GL_INT:
case GL_UNSIGNED_INT: {
GLint *dst = (GLint *) dstAddr;
dst[i] = lum32;
+ break;
}
- break;
}
}
return;
GLbyte *dst = (GLbyte *) dstAddr;
dst[2*i] = lum32;
dst[2*i+1] = alpha;
+ break;
}
case GL_SHORT:
case GL_UNSIGNED_SHORT: {
GLshort *dst = (GLshort *) dstAddr;
dst[i] = lum32;
dst[2*i+1] = alpha;
+ break;
}
- break;
case GL_INT:
case GL_UNSIGNED_INT: {
GLint *dst = (GLint *) dstAddr;
dst[i] = lum32;
dst[2*i+1] = alpha;
+ break;
}
- break;
}
}
return;