}
-/**
- * Make temporary image with uint pixel values. Used for unsigned
- * integer-valued textures.
- */
-static GLuint *
-make_temp_uint_image(struct gl_context *ctx, GLuint dims,
- GLenum logicalBaseFormat,
- GLenum textureBaseFormat,
- GLint srcWidth, GLint srcHeight, GLint srcDepth,
- GLenum srcFormat, GLenum srcType,
- const GLvoid *srcAddr,
- const struct gl_pixelstore_attrib *srcPacking)
-{
- GLuint *tempImage;
- const GLint components = _mesa_components_in_format(logicalBaseFormat);
- const GLint srcStride =
- _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
- GLuint *dst;
- GLint img, row;
-
- ASSERT(dims >= 1 && dims <= 3);
-
- ASSERT(logicalBaseFormat == GL_RGBA ||
- logicalBaseFormat == GL_RGB ||
- logicalBaseFormat == GL_RG ||
- logicalBaseFormat == GL_RED ||
- logicalBaseFormat == GL_LUMINANCE_ALPHA ||
- logicalBaseFormat == GL_LUMINANCE ||
- logicalBaseFormat == GL_INTENSITY ||
- logicalBaseFormat == GL_ALPHA);
-
- ASSERT(textureBaseFormat == GL_RGBA ||
- textureBaseFormat == GL_RGB ||
- textureBaseFormat == GL_RG ||
- textureBaseFormat == GL_RED ||
- textureBaseFormat == GL_LUMINANCE_ALPHA ||
- textureBaseFormat == GL_LUMINANCE ||
- textureBaseFormat == GL_INTENSITY ||
- textureBaseFormat == GL_ALPHA);
-
- tempImage = malloc(srcWidth * srcHeight * srcDepth
- * components * sizeof(GLuint));
- if (!tempImage)
- return NULL;
-
- dst = tempImage;
- for (img = 0; img < srcDepth; img++) {
- const GLubyte *src
- = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
- srcWidth, srcHeight,
- srcFormat, srcType,
- img, 0, 0);
- for (row = 0; row < srcHeight; row++) {
- _mesa_unpack_color_span_uint(ctx, srcWidth, logicalBaseFormat,
- dst, srcFormat, srcType, src,
- srcPacking);
- dst += srcWidth * components;
- src += srcStride;
- }
- }
-
- if (logicalBaseFormat != textureBaseFormat) {
- /* more work */
- GLint texComponents = _mesa_components_in_format(textureBaseFormat);
- GLint logComponents = _mesa_components_in_format(logicalBaseFormat);
- GLuint *newImage;
- GLint i, n;
- GLubyte map[6];
-
- /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */
- ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||
- textureBaseFormat == GL_LUMINANCE_ALPHA);
-
- /* The actual texture format should have at least as many components
- * as the logical texture format.
- */
- ASSERT(texComponents >= logComponents);
-
- newImage = malloc(srcWidth * srcHeight * srcDepth
- * texComponents * sizeof(GLuint));
- if (!newImage) {
- free(tempImage);
- return NULL;
- }
-
- _mesa_compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);
-
- n = srcWidth * srcHeight * srcDepth;
- for (i = 0; i < n; i++) {
- GLint k;
- for (k = 0; k < texComponents; k++) {
- GLint j = map[k];
- if (j == ZERO)
- newImage[i * texComponents + k] = 0;
- else if (j == ONE)
- newImage[i * texComponents + k] = 1;
- else
- newImage[i * texComponents + k] = tempImage[i * logComponents + j];
- }
- }
-
- free(tempImage);
- tempImage = newImage;
- }
-
- return tempImage;
-}
-
-
-
/**
* Make a temporary (color) texture image with GLubyte components.
* Apply all needed pixel unpacking and pixel transfer operations.
}
-/**
- * General-case function for storing a color texture images with
- * components that can be represented with ubytes. Example destination
- * texture formats are MESA_FORMAT_ARGB888, ARGB4444, RGB565.
- */
-static GLboolean
-store_ubyte_texture(TEXSTORE_PARAMS)
-{
- const GLint srcRowStride = srcWidth * 4 * sizeof(GLubyte);
- GLubyte *tempImage, *src;
- GLint img;
-
- tempImage = _mesa_make_temp_ubyte_image(ctx, dims,
- baseInternalFormat,
- GL_RGBA,
- srcWidth, srcHeight, srcDepth,
- srcFormat, srcType, srcAddr,
- srcPacking);
- if (!tempImage)
- return GL_FALSE;
-
- /* This way we will use the RGB versions of the packing functions and it
- * will work for both RGB and sRGB textures*/
- dstFormat = _mesa_get_srgb_format_linear(dstFormat);
-
- src = tempImage;
- for (img = 0; img < srcDepth; img++) {
- _mesa_pack_ubyte_rgba_rect(dstFormat, srcWidth, srcHeight,
- src, srcRowStride,
- dstSlices[img], dstRowStride);
- src += srcHeight * srcRowStride;
- }
- free(tempImage);
-
- return GL_TRUE;
-}
-
-
-
-
/**
* Store a 32-bit integer or float depth component texture image.
*/
}
-/**
- * Store an rgb565 or rgb565_rev texture image.
- */
-static GLboolean
-_mesa_texstore_rgb565(TEXSTORE_PARAMS)
-{
- ASSERT(dstFormat == MESA_FORMAT_B5G6R5_UNORM ||
- dstFormat == MESA_FORMAT_R5G6B5_UNORM);
- ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
-
- if (!ctx->_ImageTransferState &&
- !srcPacking->SwapBytes &&
- baseInternalFormat == GL_RGB &&
- srcFormat == GL_RGB &&
- srcType == GL_UNSIGNED_BYTE &&
- dims == 2) {
- /* do optimized tex store */
- const GLint srcRowStride =
- _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
- const GLubyte *src = (const GLubyte *)
- _mesa_image_address(dims, srcPacking, srcAddr, srcWidth, srcHeight,
- srcFormat, srcType, 0, 0, 0);
- GLubyte *dst = dstSlices[0];
- GLint row, col;
- for (row = 0; row < srcHeight; row++) {
- const GLubyte *srcUB = (const GLubyte *) src;
- GLushort *dstUS = (GLushort *) dst;
- /* check for byteswapped format */
- if (dstFormat == MESA_FORMAT_B5G6R5_UNORM) {
- for (col = 0; col < srcWidth; col++) {
- dstUS[col] = PACK_COLOR_565( srcUB[0], srcUB[1], srcUB[2] );
- srcUB += 3;
- }
- }
- else {
- for (col = 0; col < srcWidth; col++) {
- dstUS[col] = PACK_COLOR_565( srcUB[2], srcUB[1], srcUB[0] );
- srcUB += 3;
- }
- }
- dst += dstRowStride;
- src += srcRowStride;
- }
- return GL_TRUE;
- } else {
- return GL_FALSE;
- }
-}
-
-
/**
* Texstore for _mesa_texformat_ycbcr or _mesa_texformat_ycbcr_REV.
*/
return GL_TRUE;
}
-static GLboolean
-_mesa_texstore_argb2101010_uint(TEXSTORE_PARAMS)
-{
- const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
- ASSERT(dstFormat == MESA_FORMAT_B10G10R10A2_UINT);
- ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
-
- {
- /* general path */
- const GLuint *tempImage = make_temp_uint_image(ctx, dims,
- baseInternalFormat,
- baseFormat,
- srcWidth, srcHeight,
- srcDepth, srcFormat,
- srcType, srcAddr,
- srcPacking);
- const GLuint *src = tempImage;
- GLint img, row, col;
- GLboolean is_unsigned = _mesa_is_type_unsigned(srcType);
- if (!tempImage)
- return GL_FALSE;
- for (img = 0; img < srcDepth; img++) {
- GLubyte *dstRow = dstSlices[img];
-
- for (row = 0; row < srcHeight; row++) {
- GLuint *dstUI = (GLuint *) dstRow;
- if (is_unsigned) {
- for (col = 0; col < srcWidth; col++) {
- GLushort a,r,g,b;
- r = MIN2(src[RCOMP], 0x3ff);
- g = MIN2(src[GCOMP], 0x3ff);
- b = MIN2(src[BCOMP], 0x3ff);
- a = MIN2(src[ACOMP], 0x003);
- dstUI[col] = (a << 30) | (r << 20) | (g << 10) | (b);
- src += 4;
- }
- } else {
- for (col = 0; col < srcWidth; col++) {
- GLushort a,r,g,b;
- r = CLAMP((GLint) src[RCOMP], 0, 0x3ff);
- g = CLAMP((GLint) src[GCOMP], 0, 0x3ff);
- b = CLAMP((GLint) src[BCOMP], 0, 0x3ff);
- a = CLAMP((GLint) src[ACOMP], 0, 0x003);
- dstUI[col] = (a << 30) | (r << 20) | (g << 10) | (b);
- src += 4;
- }
- }
- dstRow += dstRowStride;
- }
- }
- free((void *) tempImage);
- }
- return GL_TRUE;
-}
-
-static GLboolean
-_mesa_texstore_abgr2101010_uint(TEXSTORE_PARAMS)
-{
- const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
- ASSERT(dstFormat == MESA_FORMAT_R10G10B10A2_UINT);
- ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
-
- {
- /* general path */
- const GLuint *tempImage = make_temp_uint_image(ctx, dims,
- baseInternalFormat,
- baseFormat,
- srcWidth, srcHeight,
- srcDepth, srcFormat,
- srcType, srcAddr,
- srcPacking);
- const GLuint *src = tempImage;
- GLint img, row, col;
- GLboolean is_unsigned = _mesa_is_type_unsigned(srcType);
- if (!tempImage)
- return GL_FALSE;
- for (img = 0; img < srcDepth; img++) {
- GLubyte *dstRow = dstSlices[img];
-
- for (row = 0; row < srcHeight; row++) {
- GLuint *dstUI = (GLuint *) dstRow;
- if (is_unsigned) {
- for (col = 0; col < srcWidth; col++) {
- GLushort a,r,g,b;
- r = MIN2(src[RCOMP], 0x3ff);
- g = MIN2(src[GCOMP], 0x3ff);
- b = MIN2(src[BCOMP], 0x3ff);
- a = MIN2(src[ACOMP], 0x003);
- dstUI[col] = (a << 30) | (b << 20) | (g << 10) | (r);
- src += 4;
- }
- } else {
- for (col = 0; col < srcWidth; col++) {
- GLushort a,r,g,b;
- r = CLAMP((GLint) src[RCOMP], 0, 0x3ff);
- g = CLAMP((GLint) src[GCOMP], 0, 0x3ff);
- b = CLAMP((GLint) src[BCOMP], 0, 0x3ff);
- a = CLAMP((GLint) src[ACOMP], 0, 0x003);
- dstUI[col] = (a << 30) | (b << 20) | (g << 10) | (r);
- src += 4;
- }
- }
- dstRow += dstRowStride;
- }
- }
- free((void *) tempImage);
- }
- return GL_TRUE;
-}
-
-
static GLboolean
texstore_depth_stencil(TEXSTORE_PARAMS)
{
srcFormat, srcType, srcAddr, srcPacking);
}
-static void
-invert_swizzle(uint8_t dst[4], const uint8_t src[4])
-{
- int i, j;
-
- dst[0] = MESA_FORMAT_SWIZZLE_NONE;
- dst[1] = MESA_FORMAT_SWIZZLE_NONE;
- dst[2] = MESA_FORMAT_SWIZZLE_NONE;
- dst[3] = MESA_FORMAT_SWIZZLE_NONE;
-
- for (i = 0; i < 4; ++i)
- for (j = 0; j < 4; ++j)
- if (src[j] == i && dst[i] == MESA_FORMAT_SWIZZLE_NONE)
- dst[i] = j;
-}
-
-/** Store a texture by per-channel conversions and swizzling.
- *
- * This function attempts to perform a texstore operation by doing simple
- * per-channel conversions and swizzling. This covers a huge chunk of the
- * texture storage operations that anyone cares about. If this function is
- * incapable of performing the operation, it bails and returns GL_FALSE.
- */
static GLboolean
-texstore_swizzle(TEXSTORE_PARAMS)
+texstore_rgba(TEXSTORE_PARAMS)
{
- const GLint srcRowStride = _mesa_image_row_stride(srcPacking, srcWidth,
- srcFormat, srcType);
- const GLint srcImageStride = _mesa_image_image_stride(srcPacking,
- srcWidth, srcHeight, srcFormat, srcType);
- const GLubyte *srcImage = (const GLubyte *) _mesa_image_address(dims,
- srcPacking, srcAddr, srcWidth, srcHeight, srcFormat, srcType, 0, 0, 0);
- const int src_components = _mesa_components_in_format(srcFormat);
-
- GLubyte swizzle[4], rgba2base[6], base2src[6], rgba2dst[4], dst2rgba[4];
- const GLubyte *swap;
- GLenum dst_type;
- int dst_components;
- bool is_array, normalized, need_swap;
- GLint i, img, row;
- const GLubyte *src_row;
- GLubyte *dst_row;
-
- is_array = _mesa_format_to_array(dstFormat, &dst_type, &dst_components,
- rgba2dst, &normalized);
-
- if (!is_array)
- return GL_FALSE;
-
- if (srcFormat == GL_COLOR_INDEX)
- return GL_FALSE;
-
- if (_mesa_texstore_needs_transfer_ops(ctx, baseInternalFormat, dstFormat))
- return GL_FALSE;
-
- switch (srcType) {
- case GL_FLOAT:
- case GL_UNSIGNED_BYTE:
- case GL_BYTE:
- case GL_UNSIGNED_SHORT:
- case GL_SHORT:
- case GL_UNSIGNED_INT:
- case GL_INT:
- /* If wa have to swap bytes in a multi-byte datatype, that means
- * we're not doing an array conversion anymore */
- if (srcPacking->SwapBytes)
- return GL_FALSE;
- need_swap = false;
- break;
- case GL_UNSIGNED_INT_8_8_8_8:
- need_swap = srcPacking->SwapBytes;
- if (_mesa_little_endian())
- need_swap = !need_swap;
- srcType = GL_UNSIGNED_BYTE;
- break;
- case GL_UNSIGNED_INT_8_8_8_8_REV:
- need_swap = srcPacking->SwapBytes;
- if (!_mesa_little_endian())
- need_swap = !need_swap;
- srcType = GL_UNSIGNED_BYTE;
- break;
- default:
- return GL_FALSE;
- }
- swap = need_swap ? map_3210 : map_identity;
-
- _mesa_compute_component_mapping(srcFormat, baseInternalFormat, base2src);
- _mesa_compute_component_mapping(baseInternalFormat, GL_RGBA, rgba2base);
- invert_swizzle(dst2rgba, rgba2dst);
-
- for (i = 0; i < 4; i++) {
- if (dst2rgba[i] == MESA_FORMAT_SWIZZLE_NONE)
- swizzle[i] = MESA_FORMAT_SWIZZLE_NONE;
- else
- swizzle[i] = swap[base2src[rgba2base[dst2rgba[i]]]];
- }
-
- /* Is it normalized? */
- normalized |= !_mesa_is_enum_format_integer(srcFormat);
-
- for (img = 0; img < srcDepth; img++) {
- if (dstRowStride == srcWidth * dst_components &&
- srcRowStride == srcWidth * src_components) {
- _mesa_swizzle_and_convert(dstSlices[img], dst_type, dst_components,
- srcImage, srcType, src_components,
- swizzle, normalized, srcWidth * srcHeight);
- } else {
- src_row = srcImage;
- dst_row = dstSlices[img];
- for (row = 0; row < srcHeight; row++) {
- _mesa_swizzle_and_convert(dst_row, dst_type, dst_components,
- src_row, srcType, src_components,
- swizzle, normalized, srcWidth);
- dst_row += dstRowStride;
- src_row += srcRowStride;
- }
- }
- srcImage += srcImageStride;
+ void *tempImage = NULL;
+ int srcRowStride, img;
+ GLubyte *src;
+ uint32_t srcMesaFormat;
+ uint8_t rebaseSwizzle[4];
+ bool needRebase;
+
+ /* We have to handle MESA_FORMAT_YCBCR manually because it is a special case
+ * and _mesa_format_convert does not support it. In this case the we only
+ * allow conversions between YCBCR formats and it is mostly a memcpy.
+ */
+ if (dstFormat == MESA_FORMAT_YCBCR || dstFormat == MESA_FORMAT_YCBCR_REV) {
+ return _mesa_texstore_ycbcr(ctx, dims, baseInternalFormat,
+ dstFormat, dstRowStride, dstSlices,
+ srcWidth, srcHeight, srcDepth,
+ srcFormat, srcType, srcAddr,
+ srcPacking);
}
- return GL_TRUE;
-}
-
-
-/** Stores a texture by converting float and then to the texture format
- *
- * This function performs a texstore operation by converting to float,
- * applying pixel transfer ops, and then converting to the texture's
- * internal format using pixel store functions. This function will work
- * for any rgb or srgb textore format.
- */
-static GLboolean
-texstore_via_float(TEXSTORE_PARAMS)
-{
- GLuint i, img, row;
- const GLint src_stride =
- _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
- float *tmp_row;
- bool need_convert;
- uint8_t *src_row, *dst_row, map[4], rgba2base[6], base2rgba[6];
-
- tmp_row = malloc(srcWidth * 4 * sizeof(*tmp_row));
- if (!tmp_row)
- return GL_FALSE;
-
- /* The GL spec (4.0, compatibility profile) only specifies srgb
- * conversion as something that is done in the sampler during the
- * filtering process before the colors are handed to the shader.
- * Furthermore, the flowchart (Figure 3.7 in the 4.0 compatibility spec)
- * does not list RGB <-> sRGB conversions anywhere. Therefore, we just
- * treat sRGB formats the same as RGB formats for the purposes of
- * texture upload and transfer ops.
+ /* We have to deal with GL_COLOR_INDEX manually because
+ * _mesa_format_convert does not handle this format. So what we do here is
+ * convert it to RGBA ubyte first and then convert from that to dst as usual.
*/
- dstFormat = _mesa_get_srgb_format_linear(dstFormat);
-
- need_convert = false;
- if (baseInternalFormat != _mesa_get_format_base_format(dstFormat)) {
- _mesa_compute_component_mapping(GL_RGBA, baseInternalFormat, base2rgba);
- _mesa_compute_component_mapping(baseInternalFormat, GL_RGBA, rgba2base);
- for (i = 0; i < 4; ++i) {
- map[i] = base2rgba[rgba2base[i]];
- if (map[i] != i)
- need_convert = true;
- }
- }
+ if (srcFormat == GL_COLOR_INDEX) {
+ /* Notice that this will already handle byte swapping if necessary */
+ tempImage = _mesa_make_temp_ubyte_image(ctx, dims,
+ baseInternalFormat,
+ GL_RGBA,
+ srcWidth, srcHeight, srcDepth,
+ srcFormat, srcType, srcAddr,
+ srcPacking);
+ if (!tempImage)
+ return GL_FALSE;
- for (img = 0; img < srcDepth; img++) {
- dst_row = dstSlices[img];
- src_row = _mesa_image_address(dims, srcPacking, srcAddr,
- srcWidth, srcHeight,
- srcFormat, srcType,
- img, 0, 0);
- for (row = 0; row < srcHeight; row++) {
- _mesa_unpack_color_span_float(ctx, srcWidth, GL_RGBA, tmp_row,
- srcFormat, srcType, src_row,
- srcPacking, ctx->_ImageTransferState);
- if (need_convert)
- _mesa_swizzle_and_convert(tmp_row, GL_FLOAT, 4,
- tmp_row, GL_FLOAT, 4,
- map, false, srcWidth);
- _mesa_pack_float_rgba_row(dstFormat, srcWidth,
- (const GLfloat (*)[4])tmp_row,
- dst_row);
- dst_row += dstRowStride;
- src_row += src_stride;
+ /* Now we only have to adjust our src info for a conversion from
+ * the RGBA ubyte and then we continue as usual.
+ */
+ srcAddr = tempImage;
+ srcFormat = GL_RGBA;
+ srcType = GL_UNSIGNED_BYTE;
+ } else if (srcPacking->SwapBytes) {
+ /* We have to handle byte-swapping scenarios before calling
+ * _mesa_format_convert
+ */
+ GLint swapSize = _mesa_sizeof_packed_type(srcType);
+ if (swapSize == 2 || swapSize == 4) {
+ int components = _mesa_components_in_format(srcFormat);
+ int elementCount = srcWidth * srcHeight * components;
+ tempImage = malloc(elementCount * swapSize);
+ if (!tempImage)
+ return GL_FALSE;
+ if (swapSize == 2)
+ _mesa_swap2_copy(tempImage, (GLushort *) srcAddr, elementCount);
+ else
+ _mesa_swap4_copy(tempImage, (GLuint *) srcAddr, elementCount);
+ srcAddr = tempImage;
}
}
- free(tmp_row);
-
- return GL_TRUE;
-}
-
-/** Stores an integer rgba texture
- *
- * This function performs an integer texture storage operation by unpacking
- * the texture to 32-bit integers, and repacking it into the internal
- * format of the texture. This will work for any integer rgb texture
- * storage operation.
- */
-static GLboolean
-texstore_rgba_integer(TEXSTORE_PARAMS)
-{
- GLuint i, img, row, *tmp_row;
- GLenum dst_type, tmp_type;
- const GLint src_stride =
+ srcRowStride =
_mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
- int num_dst_components;
- bool is_array, normalized;
- uint8_t *src_row, *dst_row;
- uint8_t swizzle[4], rgba2base[6], base2rgba[6], rgba2dst[4], dst2rgba[4];
-
- tmp_row = malloc(srcWidth * 4 * sizeof(*tmp_row));
- if (!tmp_row)
- return GL_FALSE;
-
- is_array = _mesa_format_to_array(dstFormat, &dst_type, &num_dst_components,
- rgba2dst, &normalized);
-
- assert(is_array && !normalized);
- if (!is_array) {
- free(tmp_row);
- return GL_FALSE;
- }
-
- invert_swizzle(dst2rgba, rgba2dst);
- _mesa_compute_component_mapping(GL_RGBA, baseInternalFormat, base2rgba);
- _mesa_compute_component_mapping(baseInternalFormat, GL_RGBA, rgba2base);
+ src = (GLubyte *)
+ _mesa_image_address(dims, srcPacking, srcAddr, srcWidth, srcHeight,
+ srcFormat, srcType, 0, 0, 0);
- for (i = 0; i < 4; ++i) {
- if (dst2rgba[i] == MESA_FORMAT_SWIZZLE_NONE)
- swizzle[i] = MESA_FORMAT_SWIZZLE_NONE;
- else
- swizzle[i] = base2rgba[rgba2base[dst2rgba[i]]];
- }
+ srcMesaFormat = _mesa_format_from_format_and_type(srcFormat, srcType);
+ dstFormat = _mesa_get_srgb_format_linear(dstFormat);
- if (_mesa_is_type_unsigned(srcType)) {
- tmp_type = GL_UNSIGNED_INT;
+ if (_mesa_get_format_base_format(dstFormat) != baseInternalFormat) {
+ needRebase =
+ _mesa_compute_rgba2base2rgba_component_mapping(baseInternalFormat,
+ rebaseSwizzle);
} else {
- tmp_type = GL_INT;
+ needRebase = false;
}
for (img = 0; img < srcDepth; img++) {
- dst_row = dstSlices[img];
- src_row = _mesa_image_address(dims, srcPacking, srcAddr,
- srcWidth, srcHeight,
- srcFormat, srcType,
- img, 0, 0);
- for (row = 0; row < srcHeight; row++) {
- _mesa_unpack_color_span_uint(ctx, srcWidth, GL_RGBA, tmp_row,
- srcFormat, srcType, src_row, srcPacking);
- _mesa_swizzle_and_convert(dst_row, dst_type, num_dst_components,
- tmp_row, tmp_type, 4,
- swizzle, false, srcWidth);
- dst_row += dstRowStride;
- src_row += src_stride;
- }
+ _mesa_format_convert(dstSlices[img], dstFormat, dstRowStride,
+ src, srcMesaFormat, srcRowStride,
+ srcWidth, srcHeight,
+ needRebase ? rebaseSwizzle : NULL);
+ src += srcHeight * srcRowStride;
}
- free(tmp_row);
+ free(tempImage);
return GL_TRUE;
}
-static GLboolean
-texstore_rgba(TEXSTORE_PARAMS)
-{
- static StoreTexImageFunc table[MESA_FORMAT_COUNT];
- static GLboolean initialized = GL_FALSE;
-
- if (!initialized) {
- memset(table, 0, sizeof table);
-
- table[MESA_FORMAT_B5G6R5_UNORM] = _mesa_texstore_rgb565;
- table[MESA_FORMAT_R5G6B5_UNORM] = _mesa_texstore_rgb565;
- table[MESA_FORMAT_YCBCR] = _mesa_texstore_ycbcr;
- table[MESA_FORMAT_YCBCR_REV] = _mesa_texstore_ycbcr;
-
- table[MESA_FORMAT_B10G10R10A2_UINT] = _mesa_texstore_argb2101010_uint;
- table[MESA_FORMAT_R10G10B10A2_UINT] = _mesa_texstore_abgr2101010_uint;
-
- initialized = GL_TRUE;
- }
-
- if (table[dstFormat] && table[dstFormat](ctx, dims, baseInternalFormat,
- dstFormat, dstRowStride, dstSlices,
- srcWidth, srcHeight, srcDepth,
- srcFormat, srcType, srcAddr,
- srcPacking)) {
- return GL_TRUE;
- }
-
- if (texstore_swizzle(ctx, dims, baseInternalFormat,
- dstFormat,
- dstRowStride, dstSlices,
- srcWidth, srcHeight, srcDepth,
- srcFormat, srcType, srcAddr, srcPacking)) {
- return GL_TRUE;
- }
-
- if (_mesa_is_format_integer(dstFormat)) {
- return texstore_rgba_integer(ctx, dims, baseInternalFormat,
- dstFormat, dstRowStride, dstSlices,
- srcWidth, srcHeight, srcDepth,
- srcFormat, srcType, srcAddr,
- srcPacking);
- } else if (_mesa_get_format_max_bits(dstFormat) <= 8 &&
- !_mesa_is_format_signed(dstFormat)) {
- return store_ubyte_texture(ctx, dims, baseInternalFormat,
- dstFormat,
- dstRowStride, dstSlices,
- srcWidth, srcHeight, srcDepth,
- srcFormat, srcType, srcAddr, srcPacking);
- } else {
- return texstore_via_float(ctx, dims, baseInternalFormat,
- dstFormat, dstRowStride, dstSlices,
- srcWidth, srcHeight, srcDepth,
- srcFormat, srcType, srcAddr,
- srcPacking);
- }
-}
-
GLboolean
_mesa_texstore_needs_transfer_ops(struct gl_context *ctx,
GLenum baseInternalFormat,
projects / mesa.git / commitdiff