<div dir="ltr"><div>I like this patch, but I doubt it actually builds at this point in the series. There are other callers of _mesa_swizzle_and_convert. </div>--Jason </div><div class="gmail_extra"> <div class="gmail_quote">On Tue, Dec 9, 2014 at 4:07 AM, Iago Toral Quiroga <<a href="mailto:itoral@igalia.com" target="_blank">itoral@igalia.com</a>> wrote:<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">In the future we would like to have a format conversion library that is independent of GL so we can share it with Gallium. This is a step in that direction. --- src/mesa/main/format_utils.c | 262 ++++++++++++++++++++----------------------- src/mesa/main/format_utils.h | 8 +- 2 files changed, 129 insertions(+), 141 deletions(-) diff --git a/src/mesa/main/format_utils.c b/src/mesa/main/format_utils.c index fce5266..e174888 100644 --- a/src/mesa/main/format_utils.c +++ b/src/mesa/main/format_utils.c @@ -253,32 +253,6 @@ _mesa_compute_component_mapping(GLenum inFormat, GLenum outFormat, GLubyte *map) #endif } -static GLenum -gl_type_for_array_format_datatype(enum mesa_array_format_datatype type) -{ - 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; - default: - assert(!"Invalid datatype"); - return GL_NONE; - } -} - /* 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. @@ -441,7 +415,7 @@ _mesa_format_convert(void *void_dst, uint32_t dst_format, size_t dst_stride, bool src_format_is_mesa_array_format, dst_format_is_mesa_array_format; uint8_t src2dst[4], src2rgba[4], rgba2dst[4], dst2rgba[4]; uint8_t rebased_src2rgba[4]; - GLenum src_gl_type, dst_gl_type, common_gl_type; + 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]; @@ -547,9 +521,7 @@ _mesa_format_convert(void *void_dst, uint32_t dst_format, size_t dst_stride, /* 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); @@ -559,9 +531,7 @@ _mesa_format_convert(void *void_dst, uint32_t dst_format, size_t dst_stride, } 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); @@ -579,8 +549,8 @@ _mesa_format_convert(void *void_dst, uint32_t dst_format, size_t dst_stride, 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; @@ -600,8 +570,8 @@ _mesa_format_convert(void *void_dst, uint32_t dst_format, size_t dst_stride, src_integer = true; } else { switch (_mesa_get_format_datatype(src_format)) { - case GL_UNSIGNED_INT: - case GL_INT: + case MESA_ARRAY_FORMAT_TYPE_UINT: + case MESA_ARRAY_FORMAT_TYPE_INT: src_integer = true; break; } @@ -635,11 +605,11 @@ _mesa_format_convert(void *void_dst, uint32_t dst_format, size_t dst_stride, case GL_FLOAT: is_signed = true; break; - case GL_UNSIGNED_INT: + case MESA_ARRAY_FORMAT_TYPE_UINT: is_signed = false; dst_integer = true; break; - case GL_INT: + case MESA_ARRAY_FORMAT_TYPE_INT: is_signed = true; dst_integer = true; break; @@ -662,13 +632,14 @@ _mesa_format_convert(void *void_dst, uint32_t dst_format, size_t 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, + _mesa_swizzle_and_convert(tmp_uint + row * width, common_type, 4, + src, src_type, src_num_channels, rebased_src2rgba, normalized, width); src += src_stride; } @@ -677,8 +648,8 @@ _mesa_format_convert(void *void_dst, uint32_t dst_format, size_t dst_stride, _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_gl_type, 4, - tmp_uint + row * width, common_gl_type, 4, + _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; } @@ -690,8 +661,8 @@ _mesa_format_convert(void *void_dst, uint32_t dst_format, size_t dst_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; } @@ -711,8 +682,9 @@ _mesa_format_convert(void *void_dst, uint32_t dst_format, size_t dst_stride, 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, + _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; } @@ -721,8 +693,10 @@ _mesa_format_convert(void *void_dst, uint32_t dst_format, size_t dst_stride, _mesa_unpack_rgba_row(src_format, width, src, tmp_float + row * width); if (rebase_swizzle) - _mesa_swizzle_and_convert(tmp_float + row * width, GL_FLOAT, 4, - tmp_float + row * width, GL_FLOAT, 4, + _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, false, width); src += src_stride; } @@ -730,8 +704,9 @@ _mesa_format_convert(void *void_dst, uint32_t dst_format, size_t dst_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; } @@ -751,8 +726,9 @@ _mesa_format_convert(void *void_dst, uint32_t dst_format, size_t dst_stride, 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, + _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; } @@ -761,8 +737,10 @@ _mesa_format_convert(void *void_dst, uint32_t dst_format, size_t dst_stride, _mesa_unpack_ubyte_rgba_row(src_format, width, src, tmp_ubyte + row * width); if (rebase_swizzle) - _mesa_swizzle_and_convert(tmp_ubyte + row * width, GL_UNSIGNED_BYTE, 4, - tmp_ubyte + row * width, GL_UNSIGNED_BYTE, 4, + _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, false, width); src += src_stride; } @@ -770,8 +748,9 @@ _mesa_format_convert(void *void_dst, uint32_t dst_format, size_t dst_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; } @@ -830,8 +809,8 @@ _mesa_format_to_array(mesa_format format, GLenum *type, int *num_components, return true; case MESA_FORMAT_LAYOUT_PACKED: switch (*type) { - case GL_UNSIGNED_BYTE: - case GL_BYTE: + case MESA_ARRAY_FORMAT_TYPE_UBYTE: + case MESA_ARRAY_FORMAT_TYPE_BYTE: if (_mesa_get_format_max_bits(format) != 8) return false; *num_components = _mesa_get_format_bytes(format); @@ -850,8 +829,8 @@ _mesa_format_to_array(mesa_format format, GLenum *type, int *num_components, assert(!"Invalid number of components"); } break; - case GL_UNSIGNED_SHORT: - case GL_SHORT: + case MESA_ARRAY_FORMAT_TYPE_USHORT: + case MESA_ARRAY_FORMAT_TYPE_SHORT: case GL_HALF_FLOAT: if (_mesa_get_format_max_bits(format) != 16) return false; @@ -868,8 +847,8 @@ _mesa_format_to_array(mesa_format format, GLenum *type, int *num_components, assert(!"Invalid number of components"); } break; - case GL_UNSIGNED_INT: - case GL_INT: + case MESA_ARRAY_FORMAT_TYPE_UINT: + case MESA_ARRAY_FORMAT_TYPE_INT: case GL_FLOAT: /* This isn't packed. At least not really. */ assert(format_components == 1); @@ -916,8 +895,12 @@ half_to_uint(uint16_t x) * 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; @@ -931,7 +914,8 @@ swizzle_convert_try_memcpy(void *dst, GLenum dst_type, int num_dst_channels, 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; } @@ -1087,48 +1071,48 @@ convert_float(void *void_dst, int num_dst_channels, 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 { @@ -1149,48 +1133,48 @@ convert_half_float(void *void_dst, int num_dst_channels, 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 { @@ -1210,52 +1194,52 @@ convert_ubyte(void *void_dst, int num_dst_channels, 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, (src < 0) ? 0 : src); } 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_unsigned_to_unsigned(half_to_uint(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 { @@ -1276,52 +1260,52 @@ convert_byte(void *void_dst, int num_dst_channels, 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, src); } 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_float(src)); } 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 { @@ -1342,52 +1326,52 @@ convert_ushort(void *void_dst, int num_dst_channels, 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, (src < 0) ? 0 : src); } 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, half_to_uint(src)); } 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 { @@ -1408,52 +1392,52 @@ convert_short(void *void_dst, int num_dst_channels, 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, src); } 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_float(src)); } 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 { @@ -1473,52 +1457,52 @@ convert_uint(void *void_dst, int num_dst_channels, 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, (src < 0) ? 0 : src); } 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, half_to_uint(src)); } 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 { @@ -1539,56 +1523,56 @@ convert_int(void *void_dst, int num_dst_channels, 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, src); } 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_float(src)); } 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: @@ -1656,35 +1640,35 @@ _mesa_swizzle_and_convert(void *void_dst, GLenum dst_type, int 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; diff --git a/src/mesa/main/format_utils.h b/src/mesa/main/format_utils.h index ec08f27..d94cf92 100644 --- a/src/mesa/main/format_utils.h +++ b/src/mesa/main/format_utils.h @@ -174,8 +174,12 @@ _mesa_format_to_array(mesa_format, GLenum *type, int *num_components, uint8_t swizzle[4], bool *normalized); void -_mesa_swizzle_and_convert(void *dst, GLenum dst_type, int num_dst_channels, - const void *src, GLenum src_type, int num_src_channels, +_mesa_swizzle_and_convert(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); void -- 1.9.1 _______________________________________________ mesa-dev mailing list <a href="mailto:mesa-dev@lists.freedesktop.org">mesa-dev@lists.freedesktop.org</a> <a href="http://lists.freedesktop.org/mailman/listinfo/mesa-dev" target="_blank">http://lists.freedesktop.org/mailman/listinfo/mesa-dev</a> </blockquote></div></div>