* OTHER DEALINGS IN THE SOFTWARE.
*/
+#include "errors.h"
#include "format_utils.h"
#include "glformats.h"
#include "format_pack.h"
#include "format_unpack.h"
-const mesa_array_format RGBA8888_FLOAT =
- MESA_ARRAY_FORMAT(4, 1, 1, 1, 4, 0, 1, 2, 3);
+const mesa_array_format RGBA32_FLOAT =
+ MESA_ARRAY_FORMAT(MESA_ARRAY_FORMAT_BASE_FORMAT_RGBA_VARIANTS,
+ 4, 1, 1, 1, 4, 0, 1, 2, 3);
-const mesa_array_format RGBA8888_UBYTE =
- MESA_ARRAY_FORMAT(1, 0, 0, 1, 4, 0, 1, 2, 3);
+const mesa_array_format RGBA8_UBYTE =
+ MESA_ARRAY_FORMAT(MESA_ARRAY_FORMAT_BASE_FORMAT_RGBA_VARIANTS,
+ 1, 0, 0, 1, 4, 0, 1, 2, 3);
-const mesa_array_format RGBA8888_UINT =
- MESA_ARRAY_FORMAT(4, 0, 0, 0, 4, 0, 1, 2, 3);
+const mesa_array_format RGBA32_UINT =
+ MESA_ARRAY_FORMAT(MESA_ARRAY_FORMAT_BASE_FORMAT_RGBA_VARIANTS,
+ 4, 0, 0, 0, 4, 0, 1, 2, 3);
-const mesa_array_format RGBA8888_INT =
- MESA_ARRAY_FORMAT(4, 1, 0, 0, 4, 0, 1, 2, 3);
+const mesa_array_format RGBA32_INT =
+ MESA_ARRAY_FORMAT(MESA_ARRAY_FORMAT_BASE_FORMAT_RGBA_VARIANTS,
+ 4, 1, 0, 0, 4, 0, 1, 2, 3);
static void
invert_swizzle(uint8_t dst[4], const uint8_t src[4])
dst[i] = j;
}
-static GLenum
-gl_type_for_array_format_datatype(enum mesa_array_format_datatype type)
+/* Takes a src to RGBA swizzle and applies a rebase swizzle to it. This
+ * is used when we need to rebase a format to match a different
+ * base internal format.
+ *
+ * The rebase swizzle can be NULL, which means that no rebase is necessary,
+ * in which case the src to RGBA swizzle is copied to the output without
+ * changes.
+ *
+ * The resulting rebased swizzle and well as the input swizzles are
+ * all 4-element swizzles, but the rebase swizzle can be NULL if no rebase
+ * is necessary.
+ */
+static void
+compute_rebased_rgba_component_mapping(uint8_t *src2rgba,
+ uint8_t *rebase_swizzle,
+ uint8_t *rebased_src2rgba)
{
- switch (type) {
- case MESA_ARRAY_FORMAT_TYPE_UBYTE:
- return GL_UNSIGNED_BYTE;
- case MESA_ARRAY_FORMAT_TYPE_USHORT:
- return GL_UNSIGNED_SHORT;
- case MESA_ARRAY_FORMAT_TYPE_UINT:
- return GL_UNSIGNED_INT;
- case MESA_ARRAY_FORMAT_TYPE_BYTE:
- return GL_BYTE;
- case MESA_ARRAY_FORMAT_TYPE_SHORT:
- return GL_SHORT;
- case MESA_ARRAY_FORMAT_TYPE_INT:
- return GL_INT;
- case MESA_ARRAY_FORMAT_TYPE_HALF:
- return GL_HALF_FLOAT;
- case MESA_ARRAY_FORMAT_TYPE_FLOAT:
- return GL_FLOAT;
+ int i;
+
+ if (rebase_swizzle) {
+ for (i = 0; i < 4; i++) {
+ if (rebase_swizzle[i] > MESA_FORMAT_SWIZZLE_W)
+ rebased_src2rgba[i] = rebase_swizzle[i];
+ else
+ rebased_src2rgba[i] = src2rgba[rebase_swizzle[i]];
+ }
+ } else {
+ /* No rebase needed, so src2rgba is all that we need */
+ memcpy(rebased_src2rgba, src2rgba, 4 * sizeof(uint8_t));
+ }
+}
+
+/* Computes the final swizzle transform to apply from src to dst in a
+ * conversion that might involve a rebase swizzle.
+ *
+ * This is used to compute the swizzle transform to apply in conversions
+ * between array formats where we have a src2rgba swizzle, a rgba2dst swizzle
+ * and possibly, a rebase swizzle.
+ *
+ * The final swizzle transform to apply (src2dst) when a rebase swizzle is
+ * involved is: src -> rgba -> base -> rgba -> dst
+ */
+static void
+compute_src2dst_component_mapping(uint8_t *src2rgba, uint8_t *rgba2dst,
+ uint8_t *rebase_swizzle, uint8_t *src2dst)
+{
+ int i;
+
+ if (!rebase_swizzle) {
+ for (i = 0; i < 4; i++) {
+ if (rgba2dst[i] > MESA_FORMAT_SWIZZLE_W) {
+ src2dst[i] = rgba2dst[i];
+ } else {
+ src2dst[i] = src2rgba[rgba2dst[i]];
+ }
+ }
+ } else {
+ for (i = 0; i < 4; i++) {
+ if (rgba2dst[i] > MESA_FORMAT_SWIZZLE_W) {
+ src2dst[i] = rgba2dst[i];
+ } else if (rebase_swizzle[rgba2dst[i]] > MESA_FORMAT_SWIZZLE_W) {
+ src2dst[i] = rebase_swizzle[rgba2dst[i]];
+ } else {
+ src2dst[i] = src2rgba[rebase_swizzle[rgba2dst[i]]];
+ }
+ }
+ }
+}
+
+/**
+ * This function is used by clients of _mesa_format_convert to obtain
+ * the rebase swizzle to use in a format conversion based on the base
+ * format involved.
+ *
+ * \param baseFormat the base internal format involved in the conversion.
+ * \param map the rebase swizzle to consider
+ *
+ * This function computes 'map' as rgba -> baseformat -> rgba and returns true
+ * if the resulting swizzle transform is not the identity transform (thus, a
+ * rebase is needed). If the function returns false then a rebase swizzle
+ * is not necessary and the value of 'map' is undefined. In this situation
+ * clients of _mesa_format_convert should pass NULL in the 'rebase_swizzle'
+ * parameter.
+ */
+bool
+_mesa_compute_rgba2base2rgba_component_mapping(GLenum baseFormat, uint8_t *map)
+{
+ uint8_t rgba2base[6], base2rgba[6];
+ int i;
+
+ switch (baseFormat) {
+ case GL_ALPHA:
+ case GL_RED:
+ case GL_GREEN:
+ case GL_BLUE:
+ case GL_RG:
+ case GL_RGB:
+ case GL_BGR:
+ case GL_RGBA:
+ case GL_BGRA:
+ case GL_ABGR_EXT:
+ case GL_LUMINANCE:
+ case GL_INTENSITY:
+ case GL_LUMINANCE_ALPHA:
+ {
+ bool needRebase = false;
+ _mesa_compute_component_mapping(GL_RGBA, baseFormat, rgba2base);
+ _mesa_compute_component_mapping(baseFormat, GL_RGBA, base2rgba);
+ for (i = 0; i < 4; i++) {
+ if (base2rgba[i] > MESA_FORMAT_SWIZZLE_W) {
+ map[i] = base2rgba[i];
+ } else {
+ map[i] = rgba2base[base2rgba[i]];
+ }
+ if (map[i] != i)
+ needRebase = true;
+ }
+ return needRebase;
+ }
default:
- assert(!"Invalid datatype");
- return GL_NONE;
+ unreachable("Unexpected base format");
}
}
+
+/**
+ * Special case conversion function to swap r/b channels from the source
+ * image to the dest image.
+ */
+static void
+convert_ubyte_rgba_to_bgra(size_t width, size_t height,
+ const uint8_t *src, size_t src_stride,
+ uint8_t *dst, size_t dst_stride)
+{
+ int row;
+
+ if (sizeof(void *) == 8 &&
+ src_stride % 8 == 0 &&
+ dst_stride % 8 == 0 &&
+ (GLsizeiptr) src % 8 == 0 &&
+ (GLsizeiptr) dst % 8 == 0) {
+ /* use 64-bit word to swizzle two 32-bit pixels. We need 8-byte
+ * alignment for src/dst addresses and strides.
+ */
+ for (row = 0; row < height; row++) {
+ const GLuint64 *s = (const GLuint64 *) src;
+ GLuint64 *d = (GLuint64 *) dst;
+ int i;
+ for (i = 0; i < width/2; i++) {
+ d[i] = ( (s[i] & 0xff00ff00ff00ff00) |
+ ((s[i] & 0xff000000ff) << 16) |
+ ((s[i] & 0xff000000ff0000) >> 16));
+ }
+ if (width & 1) {
+ /* handle the case of odd widths */
+ const GLuint s = ((const GLuint *) src)[width - 1];
+ GLuint *d = (GLuint *) dst + width - 1;
+ *d = ( (s & 0xff00ff00) |
+ ((s & 0xff) << 16) |
+ ((s & 0xff0000) >> 16));
+ }
+ src += src_stride;
+ dst += dst_stride;
+ }
+ } else {
+ for (row = 0; row < height; row++) {
+ const GLuint *s = (const GLuint *) src;
+ GLuint *d = (GLuint *) dst;
+ int i;
+ for (i = 0; i < width; i++) {
+ d[i] = ( (s[i] & 0xff00ff00) |
+ ((s[i] & 0xff) << 16) |
+ ((s[i] & 0xff0000) >> 16));
+ }
+ src += src_stride;
+ dst += dst_stride;
+ }
+ }
+}
+
+
/**
* This can be used to convert between most color formats.
*
* \param src_stride The stride of the source format in bytes.
* \param width The width, in pixels, of the source image to convert.
* \param height The height, in pixels, of the source image to convert.
+ * \param rebase_swizzle A swizzle transform to apply during the conversion,
+ * typically used to match a different internal base
+ * format involved. NULL if no rebase transform is needed
+ * (i.e. the internal base format and the base format of
+ * the dst or the src -depending on whether we are doing
+ * an upload or a download respectively- are the same).
*/
void
_mesa_format_convert(void *void_dst, uint32_t dst_format, size_t dst_stride,
void *void_src, uint32_t src_format, size_t src_stride,
- size_t width, size_t height)
+ size_t width, size_t height, uint8_t *rebase_swizzle)
{
uint8_t *dst = (uint8_t *)void_dst;
uint8_t *src = (uint8_t *)void_src;
mesa_array_format src_array_format, dst_array_format;
bool src_format_is_mesa_array_format, dst_format_is_mesa_array_format;
uint8_t src2dst[4], src2rgba[4], rgba2dst[4], dst2rgba[4];
- GLenum src_gl_type, dst_gl_type, common_gl_type;
+ uint8_t rebased_src2rgba[4];
+ enum mesa_array_format_datatype src_type = 0, dst_type = 0, common_type;
bool normalized, dst_integer, src_integer, is_signed;
int src_num_channels = 0, dst_num_channels = 0;
uint8_t (*tmp_ubyte)[4];
float (*tmp_float)[4];
uint32_t (*tmp_uint)[4];
- int i, bits;
+ int bits;
size_t row;
if (_mesa_format_is_mesa_array_format(src_format)) {
dst_array_format = _mesa_format_to_array_format(dst_format);
}
- /* Handle the cases where we can directly unpack */
- if (!src_format_is_mesa_array_format) {
- if (dst_array_format == RGBA8888_FLOAT) {
- for (row = 0; row < height; ++row) {
- _mesa_unpack_rgba_row(src_format, width,
- src, (float (*)[4])dst);
- src += src_stride;
- dst += dst_stride;
- }
- return;
- } else if (dst_array_format == RGBA8888_UBYTE) {
- assert(!_mesa_is_format_integer_color(src_format));
- for (row = 0; row < height; ++row) {
- _mesa_unpack_ubyte_rgba_row(src_format, width,
- src, (uint8_t (*)[4])dst);
- src += src_stride;
- dst += dst_stride;
- }
- return;
- } else if (dst_array_format == RGBA8888_UINT &&
- _mesa_is_format_unsigned(src_format)) {
- assert(_mesa_is_format_integer_color(src_format));
- for (row = 0; row < height; ++row) {
- _mesa_unpack_uint_rgba_row(src_format, width,
- src, (uint32_t (*)[4])dst);
+ /* First we see if we can implement the conversion with a direct pack
+ * or unpack.
+ *
+ * In this case we want to be careful when we need to apply a swizzle to
+ * match an internal base format, since in these cases a simple pack/unpack
+ * to the dst format from the src format may not match the requirements
+ * of the internal base format. For now we decide to be safe and
+ * avoid this path in these scenarios but in the future we may want to
+ * enable it for specific combinations that are known to work.
+ */
+ if (!rebase_swizzle) {
+ /* Do a direct memcpy where possible */
+ if ((dst_format_is_mesa_array_format &&
+ src_format_is_mesa_array_format &&
+ src_array_format == dst_array_format) ||
+ src_format == dst_format) {
+ int format_size = _mesa_get_format_bytes(src_format);
+ for (row = 0; row < height; row++) {
+ memcpy(dst, src, width * format_size);
src += src_stride;
dst += dst_stride;
}
return;
}
- }
- /* Handle the cases where we can directly pack */
- if (!dst_format_is_mesa_array_format) {
- if (src_array_format == RGBA8888_FLOAT) {
- for (row = 0; row < height; ++row) {
- _mesa_pack_float_rgba_row(dst_format, width,
- (const float (*)[4])src, dst);
- src += src_stride;
- dst += dst_stride;
- }
- return;
- } else if (src_array_format == RGBA8888_UBYTE) {
- assert(!_mesa_is_format_integer_color(dst_format));
- for (row = 0; row < height; ++row) {
- _mesa_pack_ubyte_rgba_row(dst_format, width,
- (const uint8_t (*)[4])src, dst);
- src += src_stride;
- dst += dst_stride;
+ /* Handle the cases where we can directly unpack */
+ if (!src_format_is_mesa_array_format) {
+ if (dst_array_format == RGBA32_FLOAT) {
+ for (row = 0; row < height; ++row) {
+ _mesa_unpack_rgba_row(src_format, width,
+ src, (float (*)[4])dst);
+ src += src_stride;
+ dst += dst_stride;
+ }
+ return;
+ } else if (dst_array_format == RGBA8_UBYTE) {
+ assert(!_mesa_is_format_integer_color(src_format));
+ for (row = 0; row < height; ++row) {
+ _mesa_unpack_ubyte_rgba_row(src_format, width,
+ src, (uint8_t (*)[4])dst);
+ src += src_stride;
+ dst += dst_stride;
+ }
+ return;
+ } else if (dst_array_format == RGBA32_UINT &&
+ _mesa_is_format_unsigned(src_format)) {
+ assert(_mesa_is_format_integer_color(src_format));
+ for (row = 0; row < height; ++row) {
+ _mesa_unpack_uint_rgba_row(src_format, width,
+ src, (uint32_t (*)[4])dst);
+ src += src_stride;
+ dst += dst_stride;
+ }
+ return;
}
- return;
- } else if (src_array_format == RGBA8888_UINT &&
- _mesa_is_format_unsigned(dst_format)) {
- assert(_mesa_is_format_integer_color(dst_format));
- for (row = 0; row < height; ++row) {
- _mesa_pack_uint_rgba_row(dst_format, width,
- (const uint32_t (*)[4])src, dst);
- src += src_stride;
- dst += dst_stride;
+ }
+
+ /* Handle the cases where we can directly pack */
+ if (!dst_format_is_mesa_array_format) {
+ if (src_array_format == RGBA32_FLOAT) {
+ for (row = 0; row < height; ++row) {
+ _mesa_pack_float_rgba_row(dst_format, width,
+ (const float (*)[4])src, dst);
+ src += src_stride;
+ dst += dst_stride;
+ }
+ return;
+ } else if (src_array_format == RGBA8_UBYTE) {
+ assert(!_mesa_is_format_integer_color(dst_format));
+
+ if (dst_format == MESA_FORMAT_B8G8R8A8_UNORM) {
+ convert_ubyte_rgba_to_bgra(width, height, src, src_stride,
+ dst, dst_stride);
+ }
+ else {
+ for (row = 0; row < height; ++row) {
+ _mesa_pack_ubyte_rgba_row(dst_format, width,
+ (const uint8_t (*)[4])src, dst);
+ src += src_stride;
+ dst += dst_stride;
+ }
+ }
+ return;
+ } else if (src_array_format == RGBA32_UINT &&
+ _mesa_is_format_unsigned(dst_format)) {
+ assert(_mesa_is_format_integer_color(dst_format));
+ for (row = 0; row < height; ++row) {
+ _mesa_pack_uint_rgba_row(dst_format, width,
+ (const uint32_t (*)[4])src, dst);
+ src += src_stride;
+ dst += dst_stride;
+ }
+ return;
}
- return;
}
}
/* Handle conversions between array formats */
normalized = false;
if (src_array_format) {
- enum mesa_array_format_datatype datatype =
- _mesa_array_format_get_datatype(src_array_format);
- src_gl_type = gl_type_for_array_format_datatype(datatype);
+ src_type = _mesa_array_format_get_datatype(src_array_format);
src_num_channels = _mesa_array_format_get_num_channels(src_array_format);
}
if (dst_array_format) {
- enum mesa_array_format_datatype datatype =
- _mesa_array_format_get_datatype(dst_array_format);
- dst_gl_type = gl_type_for_array_format_datatype(datatype);
+ dst_type = _mesa_array_format_get_datatype(dst_array_format);
dst_num_channels = _mesa_array_format_get_num_channels(dst_array_format);
assert(_mesa_array_format_is_normalized(src_array_format) ==
_mesa_array_format_is_normalized(dst_array_format));
- for (i = 0; i < 4; i++) {
- if (rgba2dst[i] > MESA_FORMAT_SWIZZLE_W) {
- src2dst[i] = rgba2dst[i];
- } else {
- src2dst[i] = src2rgba[rgba2dst[i]];
- }
- }
+ compute_src2dst_component_mapping(src2rgba, rgba2dst, rebase_swizzle,
+ src2dst);
for (row = 0; row < height; ++row) {
- _mesa_swizzle_and_convert(dst, dst_gl_type, dst_num_channels,
- src, src_gl_type, src_num_channels,
+ _mesa_swizzle_and_convert(dst, dst_type, dst_num_channels,
+ src, src_type, src_num_channels,
src2dst, normalized, width);
src += src_stride;
dst += dst_stride;
* _mesa_swizzle_and_convert for signed formats, which is aware of the
* truncation problem.
*/
- common_gl_type = is_signed ? GL_INT : GL_UNSIGNED_INT;
+ common_type = is_signed ? MESA_ARRAY_FORMAT_TYPE_INT :
+ MESA_ARRAY_FORMAT_TYPE_UINT;
if (src_array_format) {
+ compute_rebased_rgba_component_mapping(src2rgba, rebase_swizzle,
+ rebased_src2rgba);
for (row = 0; row < height; ++row) {
- _mesa_swizzle_and_convert(tmp_uint + row * width, common_gl_type, 4,
- src, src_gl_type, src_num_channels,
- src2rgba, normalized, width);
+ _mesa_swizzle_and_convert(tmp_uint + row * width, common_type, 4,
+ src, src_type, src_num_channels,
+ rebased_src2rgba, normalized, width);
src += src_stride;
}
} else {
for (row = 0; row < height; ++row) {
_mesa_unpack_uint_rgba_row(src_format, width,
src, tmp_uint + row * width);
+ if (rebase_swizzle)
+ _mesa_swizzle_and_convert(tmp_uint + row * width, common_type, 4,
+ tmp_uint + row * width, common_type, 4,
+ rebase_swizzle, false, width);
src += src_stride;
}
}
*/
if (dst_format_is_mesa_array_format) {
for (row = 0; row < height; ++row) {
- _mesa_swizzle_and_convert(dst, dst_gl_type, dst_num_channels,
- tmp_uint + row * width, common_gl_type, 4,
+ _mesa_swizzle_and_convert(dst, dst_type, dst_num_channels,
+ tmp_uint + row * width, common_type, 4,
rgba2dst, normalized, width);
dst += dst_stride;
}
tmp_float = malloc(width * height * sizeof(*tmp_float));
if (src_format_is_mesa_array_format) {
+ compute_rebased_rgba_component_mapping(src2rgba, rebase_swizzle,
+ rebased_src2rgba);
for (row = 0; row < height; ++row) {
- _mesa_swizzle_and_convert(tmp_float + row * width, GL_FLOAT, 4,
- src, src_gl_type, src_num_channels,
- src2rgba, normalized, width);
+ _mesa_swizzle_and_convert(tmp_float + row * width,
+ MESA_ARRAY_FORMAT_TYPE_FLOAT, 4,
+ src, src_type, src_num_channels,
+ rebased_src2rgba, normalized, width);
src += src_stride;
}
} else {
for (row = 0; row < height; ++row) {
_mesa_unpack_rgba_row(src_format, width,
src, tmp_float + row * width);
+ if (rebase_swizzle)
+ _mesa_swizzle_and_convert(tmp_float + row * width,
+ MESA_ARRAY_FORMAT_TYPE_FLOAT, 4,
+ tmp_float + row * width,
+ MESA_ARRAY_FORMAT_TYPE_FLOAT, 4,
+ rebase_swizzle, normalized, width);
src += src_stride;
}
}
if (dst_format_is_mesa_array_format) {
for (row = 0; row < height; ++row) {
- _mesa_swizzle_and_convert(dst, dst_gl_type, dst_num_channels,
- tmp_float + row * width, GL_FLOAT, 4,
+ _mesa_swizzle_and_convert(dst, dst_type, dst_num_channels,
+ tmp_float + row * width,
+ MESA_ARRAY_FORMAT_TYPE_FLOAT, 4,
rgba2dst, normalized, width);
dst += dst_stride;
}
tmp_ubyte = malloc(width * height * sizeof(*tmp_ubyte));
if (src_format_is_mesa_array_format) {
+ compute_rebased_rgba_component_mapping(src2rgba, rebase_swizzle,
+ rebased_src2rgba);
for (row = 0; row < height; ++row) {
- _mesa_swizzle_and_convert(tmp_ubyte + row * width, GL_UNSIGNED_BYTE, 4,
- src, src_gl_type, src_num_channels,
- src2rgba, normalized, width);
+ _mesa_swizzle_and_convert(tmp_ubyte + row * width,
+ MESA_ARRAY_FORMAT_TYPE_UBYTE, 4,
+ src, src_type, src_num_channels,
+ rebased_src2rgba, normalized, width);
src += src_stride;
}
} else {
for (row = 0; row < height; ++row) {
_mesa_unpack_ubyte_rgba_row(src_format, width,
src, tmp_ubyte + row * width);
+ if (rebase_swizzle)
+ _mesa_swizzle_and_convert(tmp_ubyte + row * width,
+ MESA_ARRAY_FORMAT_TYPE_UBYTE, 4,
+ tmp_ubyte + row * width,
+ MESA_ARRAY_FORMAT_TYPE_UBYTE, 4,
+ rebase_swizzle, normalized, width);
src += src_stride;
}
}
if (dst_format_is_mesa_array_format) {
for (row = 0; row < height; ++row) {
- _mesa_swizzle_and_convert(dst, dst_gl_type, dst_num_channels,
- tmp_ubyte + row * width, GL_UNSIGNED_BYTE, 4,
+ _mesa_swizzle_and_convert(dst, dst_type, dst_num_channels,
+ tmp_ubyte + row * width,
+ MESA_ARRAY_FORMAT_TYPE_UBYTE, 4,
rgba2dst, normalized, width);
dst += dst_stride;
}
}
static const uint8_t map_identity[7] = { 0, 1, 2, 3, 4, 5, 6 };
+#if UTIL_ARCH_BIG_ENDIAN
static const uint8_t map_3210[7] = { 3, 2, 1, 0, 4, 5, 6 };
static const uint8_t map_1032[7] = { 1, 0, 3, 2, 4, 5, 6 };
+#endif
/**
* Describes a format as an array format, if possible
*normalized = !_mesa_is_format_integer(format);
- _mesa_format_to_type_and_comps(format, type, &format_components);
+ _mesa_uncompressed_format_to_type_and_comps(format, type, &format_components);
switch (_mesa_get_format_layout(format)) {
case MESA_FORMAT_LAYOUT_ARRAY:
endian = map_identity;
break;
case 2:
- endian = _mesa_little_endian() ? map_identity : map_1032;
+#if UTIL_ARCH_LITTLE_ENDIAN
+ endian = map_identity;
+#else
+ endian = map_1032;
+#endif
break;
case 4:
- endian = _mesa_little_endian() ? map_identity : map_3210;
+#if UTIL_ARCH_LITTLE_ENDIAN
+ endian = map_identity;
+#else
+ endian = map_3210;
+#endif
break;
default:
endian = map_identity;
endian = map_identity;
break;
case 2:
- endian = _mesa_little_endian() ? map_identity : map_1032;
+#if UTIL_ARCH_LITTLE_ENDIAN
+ endian = map_identity;
+#else
+ endian = map_1032;
+#endif
break;
default:
endian = map_identity;
* operation with memcpy, false otherwise
*/
static bool
-swizzle_convert_try_memcpy(void *dst, GLenum dst_type, int num_dst_channels,
- const void *src, GLenum src_type, int num_src_channels,
+swizzle_convert_try_memcpy(void *dst,
+ enum mesa_array_format_datatype dst_type,
+ int num_dst_channels,
+ const void *src,
+ enum mesa_array_format_datatype src_type,
+ int num_src_channels,
const uint8_t swizzle[4], bool normalized, int count)
{
int i;
if (swizzle[i] != i && swizzle[i] != MESA_FORMAT_SWIZZLE_NONE)
return false;
- memcpy(dst, src, count * num_src_channels * _mesa_sizeof_type(src_type));
+ memcpy(dst, src, count * num_src_channels *
+ _mesa_array_format_datatype_get_size(src_type));
return true;
}
const float one = 1.0f;
switch (src_type) {
- case GL_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_FLOAT:
SWIZZLE_CONVERT(float, float, src);
break;
- case GL_HALF_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_HALF:
SWIZZLE_CONVERT(float, uint16_t, _mesa_half_to_float(src));
break;
- case GL_UNSIGNED_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_UBYTE:
if (normalized) {
SWIZZLE_CONVERT(float, uint8_t, _mesa_unorm_to_float(src, 8));
} else {
SWIZZLE_CONVERT(float, uint8_t, src);
}
break;
- case GL_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_BYTE:
if (normalized) {
SWIZZLE_CONVERT(float, int8_t, _mesa_snorm_to_float(src, 8));
} else {
SWIZZLE_CONVERT(float, int8_t, src);
}
break;
- case GL_UNSIGNED_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_USHORT:
if (normalized) {
SWIZZLE_CONVERT(float, uint16_t, _mesa_unorm_to_float(src, 16));
} else {
SWIZZLE_CONVERT(float, uint16_t, src);
}
break;
- case GL_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_SHORT:
if (normalized) {
SWIZZLE_CONVERT(float, int16_t, _mesa_snorm_to_float(src, 16));
} else {
SWIZZLE_CONVERT(float, int16_t, src);
}
break;
- case GL_UNSIGNED_INT:
+ case MESA_ARRAY_FORMAT_TYPE_UINT:
if (normalized) {
SWIZZLE_CONVERT(float, uint32_t, _mesa_unorm_to_float(src, 32));
} else {
SWIZZLE_CONVERT(float, uint32_t, src);
}
break;
- case GL_INT:
+ case MESA_ARRAY_FORMAT_TYPE_INT:
if (normalized) {
SWIZZLE_CONVERT(float, int32_t, _mesa_snorm_to_float(src, 32));
} else {
const uint16_t one = _mesa_float_to_half(1.0f);
switch (src_type) {
- case GL_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_FLOAT:
SWIZZLE_CONVERT(uint16_t, float, _mesa_float_to_half(src));
break;
- case GL_HALF_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_HALF:
SWIZZLE_CONVERT(uint16_t, uint16_t, src);
break;
- case GL_UNSIGNED_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_UBYTE:
if (normalized) {
SWIZZLE_CONVERT(uint16_t, uint8_t, _mesa_unorm_to_half(src, 8));
} else {
SWIZZLE_CONVERT(uint16_t, uint8_t, _mesa_float_to_half(src));
}
break;
- case GL_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_BYTE:
if (normalized) {
SWIZZLE_CONVERT(uint16_t, int8_t, _mesa_snorm_to_half(src, 8));
} else {
SWIZZLE_CONVERT(uint16_t, int8_t, _mesa_float_to_half(src));
}
break;
- case GL_UNSIGNED_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_USHORT:
if (normalized) {
SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_unorm_to_half(src, 16));
} else {
SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_float_to_half(src));
}
break;
- case GL_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_SHORT:
if (normalized) {
SWIZZLE_CONVERT(uint16_t, int16_t, _mesa_snorm_to_half(src, 16));
} else {
SWIZZLE_CONVERT(uint16_t, int16_t, _mesa_float_to_half(src));
}
break;
- case GL_UNSIGNED_INT:
+ case MESA_ARRAY_FORMAT_TYPE_UINT:
if (normalized) {
SWIZZLE_CONVERT(uint16_t, uint32_t, _mesa_unorm_to_half(src, 32));
} else {
SWIZZLE_CONVERT(uint16_t, uint32_t, _mesa_float_to_half(src));
}
break;
- case GL_INT:
+ case MESA_ARRAY_FORMAT_TYPE_INT:
if (normalized) {
SWIZZLE_CONVERT(uint16_t, int32_t, _mesa_snorm_to_half(src, 32));
} else {
const uint8_t one = normalized ? UINT8_MAX : 1;
switch (src_type) {
- case GL_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_FLOAT:
if (normalized) {
SWIZZLE_CONVERT(uint8_t, float, _mesa_float_to_unorm(src, 8));
} else {
SWIZZLE_CONVERT(uint8_t, float, _mesa_float_to_unsigned(src, 8));
}
break;
- case GL_HALF_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_HALF:
if (normalized) {
SWIZZLE_CONVERT(uint8_t, uint16_t, _mesa_half_to_unorm(src, 8));
} else {
SWIZZLE_CONVERT(uint8_t, uint16_t, _mesa_half_to_unsigned(src, 8));
}
break;
- case GL_UNSIGNED_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_UBYTE:
SWIZZLE_CONVERT(uint8_t, uint8_t, src);
break;
- case GL_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_BYTE:
if (normalized) {
SWIZZLE_CONVERT(uint8_t, int8_t, _mesa_snorm_to_unorm(src, 8, 8));
} else {
SWIZZLE_CONVERT(uint8_t, int8_t, _mesa_signed_to_unsigned(src, 8));
}
break;
- case GL_UNSIGNED_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_USHORT:
if (normalized) {
SWIZZLE_CONVERT(uint8_t, uint16_t, _mesa_unorm_to_unorm(src, 16, 8));
} else {
SWIZZLE_CONVERT(uint8_t, uint16_t, _mesa_unsigned_to_unsigned(src, 8));
}
break;
- case GL_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_SHORT:
if (normalized) {
SWIZZLE_CONVERT(uint8_t, int16_t, _mesa_snorm_to_unorm(src, 16, 8));
} else {
SWIZZLE_CONVERT(uint8_t, int16_t, _mesa_signed_to_unsigned(src, 8));
}
break;
- case GL_UNSIGNED_INT:
+ case MESA_ARRAY_FORMAT_TYPE_UINT:
if (normalized) {
SWIZZLE_CONVERT(uint8_t, uint32_t, _mesa_unorm_to_unorm(src, 32, 8));
} else {
SWIZZLE_CONVERT(uint8_t, uint32_t, _mesa_unsigned_to_unsigned(src, 8));
}
break;
- case GL_INT:
+ case MESA_ARRAY_FORMAT_TYPE_INT:
if (normalized) {
SWIZZLE_CONVERT(uint8_t, int32_t, _mesa_snorm_to_unorm(src, 32, 8));
} else {
const int8_t one = normalized ? INT8_MAX : 1;
switch (src_type) {
- case GL_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_FLOAT:
if (normalized) {
SWIZZLE_CONVERT(uint8_t, float, _mesa_float_to_snorm(src, 8));
} else {
SWIZZLE_CONVERT(uint8_t, float, _mesa_float_to_signed(src, 8));
}
break;
- case GL_HALF_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_HALF:
if (normalized) {
SWIZZLE_CONVERT(uint8_t, uint16_t, _mesa_half_to_snorm(src, 8));
} else {
SWIZZLE_CONVERT(uint8_t, uint16_t, _mesa_half_to_signed(src, 8));
}
break;
- case GL_UNSIGNED_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_UBYTE:
if (normalized) {
SWIZZLE_CONVERT(int8_t, uint8_t, _mesa_unorm_to_snorm(src, 8, 8));
} else {
SWIZZLE_CONVERT(int8_t, uint8_t, _mesa_unsigned_to_signed(src, 8));
}
break;
- case GL_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_BYTE:
SWIZZLE_CONVERT(int8_t, int8_t, src);
break;
- case GL_UNSIGNED_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_USHORT:
if (normalized) {
SWIZZLE_CONVERT(int8_t, uint16_t, _mesa_unorm_to_snorm(src, 16, 8));
} else {
SWIZZLE_CONVERT(int8_t, uint16_t, _mesa_unsigned_to_signed(src, 8));
}
break;
- case GL_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_SHORT:
if (normalized) {
SWIZZLE_CONVERT(int8_t, int16_t, _mesa_snorm_to_snorm(src, 16, 8));
} else {
SWIZZLE_CONVERT(int8_t, int16_t, _mesa_signed_to_signed(src, 8));
}
break;
- case GL_UNSIGNED_INT:
+ case MESA_ARRAY_FORMAT_TYPE_UINT:
if (normalized) {
SWIZZLE_CONVERT(int8_t, uint32_t, _mesa_unorm_to_snorm(src, 32, 8));
} else {
SWIZZLE_CONVERT(int8_t, uint32_t, _mesa_unsigned_to_signed(src, 8));
}
break;
- case GL_INT:
+ case MESA_ARRAY_FORMAT_TYPE_INT:
if (normalized) {
SWIZZLE_CONVERT(int8_t, int32_t, _mesa_snorm_to_snorm(src, 32, 8));
} else {
const uint16_t one = normalized ? UINT16_MAX : 1;
switch (src_type) {
- case GL_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_FLOAT:
if (normalized) {
SWIZZLE_CONVERT(uint16_t, float, _mesa_float_to_unorm(src, 16));
} else {
SWIZZLE_CONVERT(uint16_t, float, _mesa_float_to_unsigned(src, 16));
}
break;
- case GL_HALF_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_HALF:
if (normalized) {
SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_half_to_unorm(src, 16));
} else {
SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_half_to_unsigned(src, 16));
}
break;
- case GL_UNSIGNED_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_UBYTE:
if (normalized) {
SWIZZLE_CONVERT(uint16_t, uint8_t, _mesa_unorm_to_unorm(src, 8, 16));
} else {
SWIZZLE_CONVERT(uint16_t, uint8_t, src);
}
break;
- case GL_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_BYTE:
if (normalized) {
SWIZZLE_CONVERT(uint16_t, int8_t, _mesa_snorm_to_unorm(src, 8, 16));
} else {
SWIZZLE_CONVERT(uint16_t, int8_t, _mesa_signed_to_unsigned(src, 16));
}
break;
- case GL_UNSIGNED_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_USHORT:
SWIZZLE_CONVERT(uint16_t, uint16_t, src);
break;
- case GL_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_SHORT:
if (normalized) {
SWIZZLE_CONVERT(uint16_t, int16_t, _mesa_snorm_to_unorm(src, 16, 16));
} else {
SWIZZLE_CONVERT(uint16_t, int16_t, _mesa_signed_to_unsigned(src, 16));
}
break;
- case GL_UNSIGNED_INT:
+ case MESA_ARRAY_FORMAT_TYPE_UINT:
if (normalized) {
SWIZZLE_CONVERT(uint16_t, uint32_t, _mesa_unorm_to_unorm(src, 32, 16));
} else {
SWIZZLE_CONVERT(uint16_t, uint32_t, _mesa_unsigned_to_unsigned(src, 16));
}
break;
- case GL_INT:
+ case MESA_ARRAY_FORMAT_TYPE_INT:
if (normalized) {
SWIZZLE_CONVERT(uint16_t, int32_t, _mesa_snorm_to_unorm(src, 32, 16));
} else {
const int16_t one = normalized ? INT16_MAX : 1;
switch (src_type) {
- case GL_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_FLOAT:
if (normalized) {
SWIZZLE_CONVERT(uint16_t, float, _mesa_float_to_snorm(src, 16));
} else {
SWIZZLE_CONVERT(uint16_t, float, _mesa_float_to_signed(src, 16));
}
break;
- case GL_HALF_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_HALF:
if (normalized) {
SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_half_to_snorm(src, 16));
} else {
SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_half_to_signed(src, 16));
}
break;
- case GL_UNSIGNED_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_UBYTE:
if (normalized) {
SWIZZLE_CONVERT(int16_t, uint8_t, _mesa_unorm_to_snorm(src, 8, 16));
} else {
SWIZZLE_CONVERT(int16_t, uint8_t, src);
}
break;
- case GL_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_BYTE:
if (normalized) {
SWIZZLE_CONVERT(int16_t, int8_t, _mesa_snorm_to_snorm(src, 8, 16));
} else {
SWIZZLE_CONVERT(int16_t, int8_t, src);
}
break;
- case GL_UNSIGNED_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_USHORT:
if (normalized) {
SWIZZLE_CONVERT(int16_t, uint16_t, _mesa_unorm_to_snorm(src, 16, 16));
} else {
SWIZZLE_CONVERT(int16_t, uint16_t, _mesa_unsigned_to_signed(src, 16));
}
break;
- case GL_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_SHORT:
SWIZZLE_CONVERT(int16_t, int16_t, src);
break;
- case GL_UNSIGNED_INT:
+ case MESA_ARRAY_FORMAT_TYPE_UINT:
if (normalized) {
SWIZZLE_CONVERT(int16_t, uint32_t, _mesa_unorm_to_snorm(src, 32, 16));
} else {
SWIZZLE_CONVERT(int16_t, uint32_t, _mesa_unsigned_to_signed(src, 16));
}
break;
- case GL_INT:
+ case MESA_ARRAY_FORMAT_TYPE_INT:
if (normalized) {
SWIZZLE_CONVERT(int16_t, int32_t, _mesa_snorm_to_snorm(src, 32, 16));
} else {
const uint32_t one = normalized ? UINT32_MAX : 1;
switch (src_type) {
- case GL_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_FLOAT:
if (normalized) {
SWIZZLE_CONVERT(uint32_t, float, _mesa_float_to_unorm(src, 32));
} else {
SWIZZLE_CONVERT(uint32_t, float, _mesa_float_to_unsigned(src, 32));
}
break;
- case GL_HALF_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_HALF:
if (normalized) {
SWIZZLE_CONVERT(uint32_t, uint16_t, _mesa_half_to_unorm(src, 32));
} else {
SWIZZLE_CONVERT(uint32_t, uint16_t, _mesa_half_to_unsigned(src, 32));
}
break;
- case GL_UNSIGNED_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_UBYTE:
if (normalized) {
SWIZZLE_CONVERT(uint32_t, uint8_t, _mesa_unorm_to_unorm(src, 8, 32));
} else {
SWIZZLE_CONVERT(uint32_t, uint8_t, src);
}
break;
- case GL_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_BYTE:
if (normalized) {
SWIZZLE_CONVERT(uint32_t, int8_t, _mesa_snorm_to_unorm(src, 8, 32));
} else {
SWIZZLE_CONVERT(uint32_t, int8_t, _mesa_signed_to_unsigned(src, 32));
}
break;
- case GL_UNSIGNED_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_USHORT:
if (normalized) {
SWIZZLE_CONVERT(uint32_t, uint16_t, _mesa_unorm_to_unorm(src, 16, 32));
} else {
SWIZZLE_CONVERT(uint32_t, uint16_t, src);
}
break;
- case GL_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_SHORT:
if (normalized) {
SWIZZLE_CONVERT(uint32_t, int16_t, _mesa_snorm_to_unorm(src, 16, 32));
} else {
SWIZZLE_CONVERT(uint32_t, int16_t, _mesa_signed_to_unsigned(src, 32));
}
break;
- case GL_UNSIGNED_INT:
+ case MESA_ARRAY_FORMAT_TYPE_UINT:
SWIZZLE_CONVERT(uint32_t, uint32_t, src);
break;
- case GL_INT:
+ case MESA_ARRAY_FORMAT_TYPE_INT:
if (normalized) {
SWIZZLE_CONVERT(uint32_t, int32_t, _mesa_snorm_to_unorm(src, 32, 32));
} else {
const int32_t one = normalized ? INT32_MAX : 1;
switch (src_type) {
- case GL_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_FLOAT:
if (normalized) {
SWIZZLE_CONVERT(uint32_t, float, _mesa_float_to_snorm(src, 32));
} else {
SWIZZLE_CONVERT(uint32_t, float, _mesa_float_to_signed(src, 32));
}
break;
- case GL_HALF_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_HALF:
if (normalized) {
SWIZZLE_CONVERT(uint32_t, uint16_t, _mesa_half_to_snorm(src, 32));
} else {
SWIZZLE_CONVERT(uint32_t, uint16_t, _mesa_half_to_signed(src, 32));
}
break;
- case GL_UNSIGNED_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_UBYTE:
if (normalized) {
SWIZZLE_CONVERT(int32_t, uint8_t, _mesa_unorm_to_snorm(src, 8, 32));
} else {
SWIZZLE_CONVERT(int32_t, uint8_t, src);
}
break;
- case GL_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_BYTE:
if (normalized) {
SWIZZLE_CONVERT(int32_t, int8_t, _mesa_snorm_to_snorm(src, 8, 32));
} else {
SWIZZLE_CONVERT(int32_t, int8_t, src);
}
break;
- case GL_UNSIGNED_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_USHORT:
if (normalized) {
SWIZZLE_CONVERT(int32_t, uint16_t, _mesa_unorm_to_snorm(src, 16, 32));
} else {
SWIZZLE_CONVERT(int32_t, uint16_t, src);
}
break;
- case GL_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_SHORT:
if (normalized) {
SWIZZLE_CONVERT(int32_t, int16_t, _mesa_snorm_to_snorm(src, 16, 32));
} else {
SWIZZLE_CONVERT(int32_t, int16_t, src);
}
break;
- case GL_UNSIGNED_INT:
+ case MESA_ARRAY_FORMAT_TYPE_UINT:
if (normalized) {
SWIZZLE_CONVERT(int32_t, uint32_t, _mesa_unorm_to_snorm(src, 32, 32));
} else {
SWIZZLE_CONVERT(int32_t, uint32_t, _mesa_unsigned_to_signed(src, 32));
}
break;
- case GL_INT:
+ case MESA_ARRAY_FORMAT_TYPE_INT:
SWIZZLE_CONVERT(int32_t, int32_t, src);
break;
default:
* \param[in] count the number of pixels to convert
*/
void
-_mesa_swizzle_and_convert(void *void_dst, GLenum dst_type, int num_dst_channels,
- const void *void_src, GLenum src_type, int num_src_channels,
+_mesa_swizzle_and_convert(void *void_dst, enum mesa_array_format_datatype dst_type, int num_dst_channels,
+ const void *void_src, enum mesa_array_format_datatype src_type, int num_src_channels,
const uint8_t swizzle[4], bool normalized, int count)
{
if (swizzle_convert_try_memcpy(void_dst, dst_type, num_dst_channels,
return;
switch (dst_type) {
- case GL_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_FLOAT:
convert_float(void_dst, num_dst_channels, void_src, src_type,
num_src_channels, swizzle, normalized, count);
break;
- case GL_HALF_FLOAT:
+ case MESA_ARRAY_FORMAT_TYPE_HALF:
convert_half_float(void_dst, num_dst_channels, void_src, src_type,
num_src_channels, swizzle, normalized, count);
break;
- case GL_UNSIGNED_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_UBYTE:
convert_ubyte(void_dst, num_dst_channels, void_src, src_type,
num_src_channels, swizzle, normalized, count);
break;
- case GL_BYTE:
+ case MESA_ARRAY_FORMAT_TYPE_BYTE:
convert_byte(void_dst, num_dst_channels, void_src, src_type,
num_src_channels, swizzle, normalized, count);
break;
- case GL_UNSIGNED_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_USHORT:
convert_ushort(void_dst, num_dst_channels, void_src, src_type,
num_src_channels, swizzle, normalized, count);
break;
- case GL_SHORT:
+ case MESA_ARRAY_FORMAT_TYPE_SHORT:
convert_short(void_dst, num_dst_channels, void_src, src_type,
num_src_channels, swizzle, normalized, count);
break;
- case GL_UNSIGNED_INT:
+ case MESA_ARRAY_FORMAT_TYPE_UINT:
convert_uint(void_dst, num_dst_channels, void_src, src_type,
num_src_channels, swizzle, normalized, count);
break;
- case GL_INT:
+ case MESA_ARRAY_FORMAT_TYPE_INT:
convert_int(void_dst, num_dst_channels, void_src, src_type,
num_src_channels, swizzle, normalized, count);
break;