map[ZERO] = ZERO;
map[ONE] = ONE;
-/*
- _mesa_printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n",
- inFormat, _mesa_lookup_enum_by_nr(inFormat),
- outFormat, _mesa_lookup_enum_by_nr(outFormat),
- map[0],
- map[1],
- map[2],
- map[3],
- map[4],
- map[5]);
-*/
-}
-
-
-#if !FEATURE_convolve
-static void
-_mesa_adjust_image_for_convolution(GLcontext *ctx, GLuint dims,
- GLsizei *srcWidth, GLsizei *srcHeight)
-{
- /* no-op */
-}
+#if 0
+ printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n",
+ inFormat, _mesa_lookup_enum_by_nr(inFormat),
+ outFormat, _mesa_lookup_enum_by_nr(outFormat),
+ map[0],
+ map[1],
+ map[2],
+ map[3],
+ map[4],
+ map[5]);
#endif
+}
/**
const GLuint postConvTransferOps
= (transferOps & IMAGE_POST_CONVOLUTION_BITS) | IMAGE_CLAMP_BIT;
GLint img, row;
- GLint convWidth, convHeight;
+ GLint convWidth = srcWidth, convHeight = srcHeight;
GLfloat *convImage;
/* pre-convolution image buffer (3D) */
- tempImage = (GLfloat *) _mesa_malloc(srcWidth * srcHeight * srcDepth
+ tempImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth
* 4 * sizeof(GLfloat));
if (!tempImage)
return NULL;
/* post-convolution image buffer (2D) */
- convImage = (GLfloat *) _mesa_malloc(srcWidth * srcHeight
+ convImage = (GLfloat *) malloc(srcWidth * srcHeight
* 4 * sizeof(GLfloat));
if (!convImage) {
- _mesa_free(tempImage);
+ free(tempImage);
return NULL;
}
}
} /* loop over 3D image slices */
- _mesa_free(convImage);
+ free(convImage);
/* might need these below */
srcWidth = convWidth;
GLfloat *dst;
GLint img, row;
- tempImage = (GLfloat *) _mesa_malloc(srcWidth * srcHeight * srcDepth
+ tempImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth
* components * sizeof(GLfloat));
if (!tempImage)
return NULL;
*/
ASSERT(texComponents >= logComponents);
- newImage = (GLfloat *) _mesa_malloc(srcWidth * srcHeight * srcDepth
+ newImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth
* texComponents * sizeof(GLfloat));
if (!newImage) {
- _mesa_free(tempImage);
+ free(tempImage);
return NULL;
}
}
}
- _mesa_free(tempImage);
+ free(tempImage);
tempImage = newImage;
}
#endif
/* unpack and transfer the source image */
- tempImage = (GLchan *) _mesa_malloc(srcWidth * srcHeight * srcDepth
+ tempImage = (GLchan *) malloc(srcWidth * srcHeight * srcDepth
* components * sizeof(GLchan));
- if (!tempImage)
+ if (!tempImage) {
+ if (freeSrcImage) {
+ free((void *) srcAddr);
+ }
return NULL;
+ }
dst = tempImage;
for (img = 0; img < srcDepth; img++) {
/* If we made a temporary image for convolution, free it here */
if (freeSrcImage) {
- _mesa_free((void *) srcAddr);
+ free((void *) srcAddr);
}
if (logicalBaseFormat != textureBaseFormat) {
*/
ASSERT(texComponents >= logComponents);
- newImage = (GLchan *) _mesa_malloc(srcWidth * srcHeight * srcDepth
+ newImage = (GLchan *) malloc(srcWidth * srcHeight * srcDepth
* texComponents * sizeof(GLchan));
if (!newImage) {
- _mesa_free(tempImage);
+ free(tempImage);
return NULL;
}
}
}
- _mesa_free(tempImage);
+ free(tempImage);
tempImage = newImage;
}
for (i = 0; i < 4; i++)
map[i] = srctype2ubyte[swap[src2base[base2rgba[rgba2dst[i]]]]];
-/* _mesa_printf("map %d %d %d %d\n", map[0], map[1], map[2], map[3]); */
+/* printf("map %d %d %d %d\n", map[0], map[1], map[2], map[3]); */
if (srcComponents == dstComponents &&
srcRowStride == dstRowStride &&
}
-#define STRIDE_3D 0
+/**
+ * Store a 24-bit integer depth component texture image.
+ */
+static GLboolean
+_mesa_texstore_z24_x8(TEXSTORE_PARAMS)
+{
+ const GLuint depthScale = 0xffffff;
+ const GLuint texelBytes = 4;
+
+ (void) dims;
+ ASSERT(dstFormat == MESA_FORMAT_Z24_X8);
+
+ {
+ /* general path */
+ GLint img, row;
+ for (img = 0; img < srcDepth; img++) {
+ GLubyte *dstRow = (GLubyte *) dstAddr
+ + dstImageOffsets[dstZoffset + img] * texelBytes
+ + dstYoffset * dstRowStride
+ + dstXoffset * texelBytes;
+ for (row = 0; row < srcHeight; row++) {
+ const GLvoid *src = _mesa_image_address(dims, srcPacking,
+ srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
+ GLuint *dst = (GLuint *) dstRow;
+ GLint i;
+ _mesa_unpack_depth_span(ctx, srcWidth,
+ GL_UNSIGNED_INT, dst,
+ depthScale, srcType, src, srcPacking);
+ for (i = 0; i < srcWidth; i++)
+ dst[i] <<= 8;
+ dstRow += dstRowStride;
+ }
+ }
+ }
+ return GL_TRUE;
+}
+
/**
* Store a 16-bit integer depth component texture image.
dstRow += dstRowStride;
}
}
- _mesa_free((void *) tempImage);
+ free((void *) tempImage);
}
return GL_TRUE;
}
dstRow += dstRowStride;
}
}
- _mesa_free((void *) tempImage);
+ free((void *) tempImage);
}
return GL_TRUE;
}
{
const GLboolean littleEndian = _mesa_little_endian();
const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
- const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+ const GLenum baseFormat = GL_RGBA;
ASSERT(dstFormat == MESA_FORMAT_ARGB8888 ||
dstFormat == MESA_FORMAT_ARGB8888_REV ||
- dstFormat == MESA_FORMAT_XRGB8888);
+ dstFormat == MESA_FORMAT_XRGB8888 ||
+ dstFormat == MESA_FORMAT_XRGB8888_REV );
ASSERT(texelBytes == 4);
if (!ctx->_ImageTransferState &&
}
else if (!ctx->_ImageTransferState &&
!srcPacking->SwapBytes &&
- dstFormat == MESA_FORMAT_ARGB8888_REV &&
+ (dstFormat == MESA_FORMAT_ARGB8888_REV ||
+ dstFormat == MESA_FORMAT_XRGB8888_REV) &&
baseInternalFormat == GL_RGBA &&
srcFormat == GL_BGRA &&
((srcType == GL_UNSIGNED_BYTE && !littleEndian) ||
*/
if ((littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||
(littleEndian && dstFormat == MESA_FORMAT_XRGB8888) ||
- (!littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV)) {
+ (!littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||
+ (!littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV)) {
dstmap[3] = 3; /* alpha */
dstmap[2] = 0; /* red */
dstmap[1] = 1; /* green */
else {
assert((littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||
(!littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||
+ (littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV) ||
(!littleEndian && dstFormat == MESA_FORMAT_XRGB8888));
dstmap[3] = 2;
dstmap[2] = 1;
dstRow += dstRowStride;
}
}
- _mesa_free((void *) tempImage);
+ free((void *) tempImage);
}
return GL_TRUE;
}
dstRow += dstRowStride;
}
}
- _mesa_free((void *) tempImage);
+ free((void *) tempImage);
}
return GL_TRUE;
}
dstRow += dstRowStride;
}
}
- _mesa_free((void *) tempImage);
+ free((void *) tempImage);
}
return GL_TRUE;
}
dstRow += dstRowStride;
}
}
- _mesa_free((void *) tempImage);
+ free((void *) tempImage);
}
return GL_TRUE;
}
dstRow += dstRowStride;
}
}
- _mesa_free((void *) tempImage);
+ free((void *) tempImage);
}
return GL_TRUE;
}
dstRow += dstRowStride;
}
}
- _mesa_free((void *) tempImage);
+ free((void *) tempImage);
}
return GL_TRUE;
}
dstRow += dstRowStride;
}
}
- _mesa_free((void *) tempImage);
+ free((void *) tempImage);
+ }
+ return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_al1616(TEXSTORE_PARAMS)
+{
+ const GLboolean littleEndian = _mesa_little_endian();
+ const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+ const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+ ASSERT(dstFormat == MESA_FORMAT_AL1616 ||
+ dstFormat == MESA_FORMAT_AL1616_REV);
+ ASSERT(texelBytes == 4);
+
+ if (!ctx->_ImageTransferState &&
+ !srcPacking->SwapBytes &&
+ dstFormat == MESA_FORMAT_AL1616 &&
+ baseInternalFormat == GL_LUMINANCE_ALPHA &&
+ srcFormat == GL_LUMINANCE_ALPHA &&
+ srcType == GL_UNSIGNED_SHORT &&
+ littleEndian) {
+ /* simple memcpy path */
+ memcpy_texture(ctx, dims,
+ dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+ dstRowStride,
+ dstImageOffsets,
+ srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+ srcAddr, srcPacking);
+ }
+ else {
+ /* general path */
+ const GLfloat *tempImage = make_temp_float_image(ctx, dims,
+ baseInternalFormat,
+ baseFormat,
+ srcWidth, srcHeight, srcDepth,
+ srcFormat, srcType, srcAddr,
+ srcPacking);
+ const GLfloat *src = tempImage;
+ GLint img, row, col;
+ if (!tempImage)
+ return GL_FALSE;
+ _mesa_adjust_image_for_convolution(ctx, dims, &srcWidth, &srcHeight);
+ for (img = 0; img < srcDepth; img++) {
+ GLubyte *dstRow = (GLubyte *) dstAddr
+ + dstImageOffsets[dstZoffset + img] * texelBytes
+ + dstYoffset * dstRowStride
+ + dstXoffset * texelBytes;
+ for (row = 0; row < srcHeight; row++) {
+ GLuint *dstUI = (GLuint *) dstRow;
+ if (dstFormat == MESA_FORMAT_AL1616) {
+ for (col = 0; col < srcWidth; col++) {
+ GLushort l, a;
+
+ UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);
+ UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);
+ dstUI[col] = PACK_COLOR_1616(a, l);
+ src += 2;
+ }
+ }
+ else {
+ for (col = 0; col < srcWidth; col++) {
+ GLushort l, a;
+
+ UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);
+ UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);
+ dstUI[col] = PACK_COLOR_1616_REV(a, l);
+ src += 2;
+ }
+ }
+ dstRow += dstRowStride;
+ }
+ }
+ free((void *) tempImage);
}
return GL_TRUE;
}
dstRow += dstRowStride;
}
}
- _mesa_free((void *) tempImage);
+ free((void *) tempImage);
}
return GL_TRUE;
}
src += srcWidth;
}
}
- _mesa_free((void *) tempImage);
+ free((void *) tempImage);
}
return GL_TRUE;
}
GLbyte *tempImage, *dst, *src;
GLint row;
- tempImage = (GLbyte *) _mesa_malloc(srcWidth * srcHeight * srcDepth
+ tempImage = (GLbyte *) malloc(srcWidth * srcHeight * srcDepth
* components * sizeof(GLbyte));
if (!tempImage)
return GL_FALSE;
dst += dstRowStride;
src += srcWidth * texelBytes;
}
- _mesa_free((void *) tempImage);
+ free((void *) tempImage);
}
return GL_TRUE;
}
dstRow += dstRowStride;
}
}
- _mesa_free((void *) tempImage);
+ free((void *) tempImage);
}
return GL_TRUE;
}
static GLboolean
_mesa_texstore_z24_s8(TEXSTORE_PARAMS)
{
- const GLfloat depthScale = (GLfloat) 0xffffff;
+ const GLuint depthScale = 0xffffff;
const GLint srcRowStride
= _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
/ sizeof(GLuint);
_mesa_unpack_depth_span(ctx, srcWidth,
GL_UNSIGNED_INT_24_8_EXT, /* dst type */
dstRow, /* dst addr */
- (GLuint) depthScale,
+ depthScale,
srcType, src, srcPacking);
/* get the 8-bit stencil values */
_mesa_unpack_stencil_span(ctx, srcWidth,
+ dstYoffset * dstRowStride
+ dstXoffset * texelBytes;
for (row = 0; row < srcHeight; row++) {
- _mesa_memcpy(dstRow, srcRow, bytesPerRow);
+ memcpy(dstRow, srcRow, bytesPerRow);
dstRow += dstRowStride;
srcRow += srcWidth * components;
}
}
- _mesa_free((void *) tempImage);
+ free((void *) tempImage);
}
return GL_TRUE;
}
}
}
- _mesa_free((void *) tempImage);
+ free((void *) tempImage);
}
return GL_TRUE;
}
return k;
}
+#else
+
+/* these are used only in texstore_funcs[] below */
+#define _mesa_texstore_srgb8 NULL
+#define _mesa_texstore_srgba8 NULL
+#define _mesa_texstore_sargb8 NULL
+#define _mesa_texstore_sl8 NULL
+#define _mesa_texstore_sla8 NULL
+
#endif /* FEATURE_EXT_texture_sRGB */
* Table mapping MESA_FORMAT_8 to _mesa_texstore_*()
* XXX this is somewhat temporary.
*/
-static struct {
+static const struct {
gl_format Name;
StoreTexImageFunc Store;
}
{ MESA_FORMAT_ARGB8888, _mesa_texstore_argb8888 },
{ MESA_FORMAT_ARGB8888_REV, _mesa_texstore_argb8888 },
{ MESA_FORMAT_XRGB8888, _mesa_texstore_argb8888 },
+ { MESA_FORMAT_XRGB8888_REV, _mesa_texstore_argb8888 },
{ MESA_FORMAT_RGB888, _mesa_texstore_rgb888 },
{ MESA_FORMAT_BGR888, _mesa_texstore_bgr888 },
{ MESA_FORMAT_RGB565, _mesa_texstore_rgb565 },
{ MESA_FORMAT_ARGB1555_REV, _mesa_texstore_argb1555 },
{ MESA_FORMAT_AL88, _mesa_texstore_al88 },
{ MESA_FORMAT_AL88_REV, _mesa_texstore_al88 },
+ { MESA_FORMAT_AL1616, _mesa_texstore_al1616 },
+ { MESA_FORMAT_AL1616_REV, _mesa_texstore_al1616 },
{ MESA_FORMAT_RGB332, _mesa_texstore_rgb332 },
{ MESA_FORMAT_A8, _mesa_texstore_a8 },
{ MESA_FORMAT_L8, _mesa_texstore_a8 },
{ MESA_FORMAT_S8_Z24, _mesa_texstore_s8_z24 },
{ MESA_FORMAT_Z16, _mesa_texstore_z16 },
{ MESA_FORMAT_X8_Z24, _mesa_texstore_x8_z24 },
+ { MESA_FORMAT_Z24_X8, _mesa_texstore_z24_x8 },
{ MESA_FORMAT_Z32, _mesa_texstore_z32 },
{ MESA_FORMAT_S8, NULL/*_mesa_texstore_s8*/ },
{ MESA_FORMAT_SRGB8, _mesa_texstore_srgb8 },
};
+static GLboolean
+_mesa_texstore_null(TEXSTORE_PARAMS)
+{
+ (void) ctx; (void) dims;
+ (void) baseInternalFormat;
+ (void) dstFormat;
+ (void) dstAddr;
+ (void) dstXoffset; (void) dstYoffset; (void) dstZoffset;
+ (void) dstRowStride; (void) dstImageOffsets;
+ (void) srcWidth; (void) srcHeight; (void) srcDepth;
+ (void) srcFormat; (void) srcType;
+ (void) srcAddr;
+ (void) srcPacking;
+
+ /* should never happen */
+ _mesa_problem(NULL, "_mesa_texstore_null() is called");
+ return GL_FALSE;
+}
+
+
/**
* Return the StoreTexImageFunc pointer to store an image in the given format.
*/
static StoreTexImageFunc
_mesa_get_texstore_func(gl_format format)
{
- GLuint i;
#ifdef DEBUG
+ GLuint i;
for (i = 0; i < MESA_FORMAT_COUNT; i++) {
ASSERT(texstore_funcs[i].Name == i);
}
#endif
ASSERT(texstore_funcs[format].Name == format);
- return texstore_funcs[format].Store;
+
+ if (texstore_funcs[format].Store)
+ return texstore_funcs[format].Store;
+ else
+ return _mesa_texstore_null;
}
storeImage = _mesa_get_texstore_func(dstFormat);
- assert(storeImage);
-
success = storeImage(ctx, dims, baseInternalFormat,
dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
dstRowStride, dstImageOffsets,
static GLuint
texture_row_stride(const struct gl_texture_image *texImage)
{
- GLuint stride;
-
- if (_mesa_is_format_compressed(texImage->TexFormat)) {
- stride = _mesa_compressed_row_stride(texImage->TexFormat,
+ GLuint stride = _mesa_format_row_stride(texImage->TexFormat,
texImage->Width);
- }
- else {
- GLuint texelBytes = _mesa_get_format_bytes(texImage->TexFormat);
- stride = texImage->RowStride * texelBytes;
- }
-
return stride;
}
GLuint sizeInBytes;
(void) border;
- texImage->TexFormat
- = ctx->Driver.ChooseTextureFormat(ctx, internalFormat, format, type);
- ASSERT(texImage->TexFormat);
-
/* allocate memory */
sizeInBytes = texture_size(texImage);
texImage->Data = _mesa_alloc_texmemory(sizeInBytes);
GLuint sizeInBytes;
(void) border;
- texImage->TexFormat
- = ctx->Driver.ChooseTextureFormat(ctx, internalFormat, format, type);
- ASSERT(texImage->TexFormat);
-
/* allocate memory */
sizeInBytes = texture_size(texImage);
texImage->Data = _mesa_alloc_texmemory(sizeInBytes);
GLuint sizeInBytes;
(void) border;
- texImage->TexFormat
- = ctx->Driver.ChooseTextureFormat(ctx, internalFormat, format, type);
- ASSERT(texImage->TexFormat);
-
/* allocate memory */
sizeInBytes = texture_size(texImage);
texImage->Data = _mesa_alloc_texmemory(sizeInBytes);
ASSERT(texImage->Depth == 1);
ASSERT(texImage->Data == NULL); /* was freed in glCompressedTexImage2DARB */
- texImage->TexFormat
- = ctx->Driver.ChooseTextureFormat(ctx, internalFormat, 0, 0);
- ASSERT(texImage->TexFormat);
-
/* allocate storage */
texImage->Data = _mesa_alloc_texmemory(imageSize);
if (!texImage->Data) {
return;
/* copy the data */
- MEMCPY(texImage->Data, data, imageSize);
+ memcpy(texImage->Data, data, imageSize);
_mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);
}
GLubyte *dest;
const GLubyte *src;
const gl_format texFormat = texImage->TexFormat;
+ const GLint destWidth = texImage->Width;
+ GLuint bw, bh;
+
+ _mesa_get_format_block_size(texFormat, &bw, &bh);
+ (void) level;
(void) format;
/* these should have been caught sooner */
- ASSERT((width & 3) == 0 || width == 2 || width == 1);
- ASSERT((height & 3) == 0 || height == 2 || height == 1);
- ASSERT((xoffset & 3) == 0);
- ASSERT((yoffset & 3) == 0);
+ ASSERT((width % bw) == 0 || width == 2 || width == 1);
+ ASSERT((height % bh) == 0 || height == 2 || height == 1);
+ ASSERT((xoffset % bw) == 0);
+ ASSERT((yoffset % bh) == 0);
/* get pointer to src pixels (may be in a pbo which we'll map here) */
data = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, data,
if (!data)
return;
- srcRowStride = _mesa_compressed_row_stride(texFormat, width);
+ srcRowStride = _mesa_format_row_stride(texFormat, width);
src = (const GLubyte *) data;
- destRowStride = _mesa_compressed_row_stride(texFormat, texImage->Width);
+ destRowStride = _mesa_format_row_stride(texFormat, destWidth);
dest = _mesa_compressed_image_address(xoffset, yoffset, 0,
- texFormat,
- texImage->Width,
+ texFormat, destWidth,
(GLubyte *) texImage->Data);
- bytesPerRow = srcRowStride;
- rows = height / 4;
+ bytesPerRow = srcRowStride; /* bytes per row of blocks */
+ rows = height / bh; /* rows in blocks */
+ /* copy rows of blocks */
for (i = 0; i < rows; i++) {
- MEMCPY(dest, src, bytesPerRow);
+ memcpy(dest, src, bytesPerRow);
dest += destRowStride;
src += srcRowStride;
}
projects / mesa.git / blobdiff