Ok, so I actually applied the patch and benchmarked it. It seems to have
improved performance in a lot of cases that were mysteriously slow! It
looks like breaking it up freed up GCC to optimize the inside better.
--Jason
On Fri, Sep 12, 2014 at 2:48 PM, Jason Ekstrand <ja...@jlekstrand.net>
wrote:
> One comment below. Otherwise, both of these look good to me.
>
> Reviewed-by: Jason Ekstrand <jason.ekstr...@intel.com>
>
> I haven't applied it and benchmarked it myself, but I don't see anything
> that would hurt performance.
> --Jason
>
> On Fri, Sep 12, 2014 at 9:17 AM, Brian Paul <bri...@vmware.com> wrote:
>
>> This reduces gcc -O3 compile time to 1/4 of what it was on my system.
>> Reduces MSVC release build time too.
>> ---
>> src/mesa/main/format_utils.c | 1030
>> ++++++++++++++++++++++--------------------
>> 1 file changed, 550 insertions(+), 480 deletions(-)
>>
>> diff --git a/src/mesa/main/format_utils.c b/src/mesa/main/format_utils.c
>> index 240e3bc..29d779a 100644
>> --- a/src/mesa/main/format_utils.c
>> +++ b/src/mesa/main/format_utils.c
>> @@ -352,9 +352,14 @@ swizzle_convert_try_memcpy(void *dst, GLenum
>> dst_type, int num_dst_channels,
>> */
>> #define SWIZZLE_CONVERT(DST_TYPE, SRC_TYPE, CONV) \
>> do { \
>> + const uint8_t swizzle_x = swizzle[0]; \
>> + const uint8_t swizzle_y = swizzle[1]; \
>> + const uint8_t swizzle_z = swizzle[2]; \
>> + const uint8_t swizzle_w = swizzle[3]; \
>>
>
> Is there a reason you got rid of the "register" qualifiers? I'm not 100%
> sure they were needed in the first place, but I was wondering if you had a
> reason.
>
>
>> const SRC_TYPE *typed_src = void_src; \
>> DST_TYPE *typed_dst = void_dst; \
>> DST_TYPE tmp[7]; \
>> + int s, j; \
>> tmp[4] = 0; \
>> tmp[5] = one; \
>> switch (num_dst_channels) { \
>> @@ -423,7 +428,527 @@ swizzle_convert_try_memcpy(void *dst, GLenum
>> dst_type, int num_dst_channels,
>> } \
>> break; \
>> } \
>> - } while (0);
>> + } while (0)
>> +
>> +
>> +static void
>> +convert_float(void *void_dst, int num_dst_channels,
>> + const void *void_src, GLenum src_type, int
>> num_src_channels,
>> + const uint8_t swizzle[4], bool normalized, int count)
>> +{
>> + const float one = 1.0f;
>> +
>> + switch (src_type) {
>> + case GL_FLOAT:
>> + SWIZZLE_CONVERT(float, float, src);
>> + break;
>> + case GL_HALF_FLOAT:
>> + SWIZZLE_CONVERT(float, uint16_t, _mesa_half_to_float(src));
>> + break;
>> + case GL_UNSIGNED_BYTE:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(float, uint8_t, unorm_to_float(src, 8));
>> + } else {
>> + SWIZZLE_CONVERT(float, uint8_t, src);
>> + }
>> + break;
>> + case GL_BYTE:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(float, int8_t, snorm_to_float(src, 8));
>> + } else {
>> + SWIZZLE_CONVERT(float, int8_t, src);
>> + }
>> + break;
>> + case GL_UNSIGNED_SHORT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(float, uint16_t, unorm_to_float(src, 16));
>> + } else {
>> + SWIZZLE_CONVERT(float, uint16_t, src);
>> + }
>> + break;
>> + case GL_SHORT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(float, int16_t, snorm_to_float(src, 16));
>> + } else {
>> + SWIZZLE_CONVERT(float, int16_t, src);
>> + }
>> + break;
>> + case GL_UNSIGNED_INT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(float, uint32_t, unorm_to_float(src, 32));
>> + } else {
>> + SWIZZLE_CONVERT(float, uint32_t, src);
>> + }
>> + break;
>> + case GL_INT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(float, int32_t, snorm_to_float(src, 32));
>> + } else {
>> + SWIZZLE_CONVERT(float, int32_t, src);
>> + }
>> + break;
>> + default:
>> + assert(!"Invalid channel type combination");
>> + }
>> +}
>> +
>> +
>> +static void
>> +convert_half_float(void *void_dst, int num_dst_channels,
>> + const void *void_src, GLenum src_type, int
>> num_src_channels,
>> + const uint8_t swizzle[4], bool normalized, int count)
>> +{
>> + const uint16_t one = _mesa_float_to_half(1.0f);
>> +
>> + switch (src_type) {
>> + case GL_FLOAT:
>> + SWIZZLE_CONVERT(uint16_t, float, _mesa_float_to_half(src));
>> + break;
>> + case GL_HALF_FLOAT:
>> + SWIZZLE_CONVERT(uint16_t, uint16_t, src);
>> + break;
>> + case GL_UNSIGNED_BYTE:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint16_t, uint8_t, unorm_to_half(src, 8));
>> + } else {
>> + SWIZZLE_CONVERT(uint16_t, uint8_t, _mesa_float_to_half(src));
>> + }
>> + break;
>> + case GL_BYTE:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint16_t, int8_t, snorm_to_half(src, 8));
>> + } else {
>> + SWIZZLE_CONVERT(uint16_t, int8_t, _mesa_float_to_half(src));
>> + }
>> + break;
>> + case GL_UNSIGNED_SHORT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint16_t, uint16_t, unorm_to_half(src, 16));
>> + } else {
>> + SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_float_to_half(src));
>> + }
>> + break;
>> + case GL_SHORT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint16_t, int16_t, snorm_to_half(src, 16));
>> + } else {
>> + SWIZZLE_CONVERT(uint16_t, int16_t, _mesa_float_to_half(src));
>> + }
>> + break;
>> + case GL_UNSIGNED_INT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint16_t, uint32_t, unorm_to_half(src, 32));
>> + } else {
>> + SWIZZLE_CONVERT(uint16_t, uint32_t, _mesa_float_to_half(src));
>> + }
>> + break;
>> + case GL_INT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint16_t, int32_t, snorm_to_half(src, 32));
>> + } else {
>> + SWIZZLE_CONVERT(uint16_t, int32_t, _mesa_float_to_half(src));
>> + }
>> + break;
>> + default:
>> + assert(!"Invalid channel type combination");
>> + }
>> +}
>> +
>> +
>> +static void
>> +convert_ubyte(void *void_dst, int num_dst_channels,
>> + const void *void_src, GLenum src_type, int
>> num_src_channels,
>> + const uint8_t swizzle[4], bool normalized, int count)
>> +{
>> + const uint8_t one = normalized ? UINT8_MAX : 1;
>> +
>> + switch (src_type) {
>> + case GL_FLOAT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint8_t, float, float_to_unorm(src, 8));
>> + } else {
>> + SWIZZLE_CONVERT(uint8_t, float, (src < 0) ? 0 : src);
>> + }
>> + break;
>> + case GL_HALF_FLOAT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_unorm(src, 8));
>> + } else {
>> + SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_uint(src));
>> + }
>> + break;
>> + case GL_UNSIGNED_BYTE:
>> + SWIZZLE_CONVERT(uint8_t, uint8_t, src);
>> + break;
>> + case GL_BYTE:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint8_t, int8_t, snorm_to_unorm(src, 8, 8));
>> + } else {
>> + SWIZZLE_CONVERT(uint8_t, int8_t, (src < 0) ? 0 : src);
>> + }
>> + break;
>> + case GL_UNSIGNED_SHORT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint8_t, uint16_t, unorm_to_unorm(src, 16, 8));
>> + } else {
>> + SWIZZLE_CONVERT(uint8_t, uint16_t, src);
>> + }
>> + break;
>> + case GL_SHORT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint8_t, int16_t, snorm_to_unorm(src, 16, 8));
>> + } else {
>> + SWIZZLE_CONVERT(uint8_t, int16_t, (src < 0) ? 0 : src);
>> + }
>> + break;
>> + case GL_UNSIGNED_INT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint8_t, uint32_t, unorm_to_unorm(src, 32, 8));
>> + } else {
>> + SWIZZLE_CONVERT(uint8_t, uint32_t, src);
>> + }
>> + break;
>> + case GL_INT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint8_t, int32_t, snorm_to_unorm(src, 32, 8));
>> + } else {
>> + SWIZZLE_CONVERT(uint8_t, int32_t, (src < 0) ? 0 : src);
>> + }
>> + break;
>> + default:
>> + assert(!"Invalid channel type combination");
>> + }
>> +}
>> +
>> +
>> +static void
>> +convert_byte(void *void_dst, int num_dst_channels,
>> + const void *void_src, GLenum src_type, int num_src_channels,
>> + const uint8_t swizzle[4], bool normalized, int count)
>> +{
>> + const int8_t one = normalized ? INT8_MAX : 1;
>> +
>> + switch (src_type) {
>> + case GL_FLOAT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint8_t, float, float_to_snorm(src, 8));
>> + } else {
>> + SWIZZLE_CONVERT(uint8_t, float, src);
>> + }
>> + break;
>> + case GL_HALF_FLOAT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_snorm(src, 8));
>> + } else {
>> + SWIZZLE_CONVERT(uint8_t, uint16_t, _mesa_half_to_float(src));
>> + }
>> + break;
>> + case GL_UNSIGNED_BYTE:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(int8_t, uint8_t, unorm_to_snorm(src, 8, 8));
>> + } else {
>> + SWIZZLE_CONVERT(int8_t, uint8_t, src);
>> + }
>> + break;
>> + case GL_BYTE:
>> + SWIZZLE_CONVERT(int8_t, int8_t, src);
>> + break;
>> + case GL_UNSIGNED_SHORT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(int8_t, uint16_t, unorm_to_snorm(src, 16, 8));
>> + } else {
>> + SWIZZLE_CONVERT(int8_t, uint16_t, src);
>> + }
>> + break;
>> + case GL_SHORT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(int8_t, int16_t, snorm_to_snorm(src, 16, 8));
>> + } else {
>> + SWIZZLE_CONVERT(int8_t, int16_t, src);
>> + }
>> + break;
>> + case GL_UNSIGNED_INT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(int8_t, uint32_t, unorm_to_snorm(src, 32, 8));
>> + } else {
>> + SWIZZLE_CONVERT(int8_t, uint32_t, src);
>> + }
>> + break;
>> + case GL_INT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(int8_t, int32_t, snorm_to_snorm(src, 32, 8));
>> + } else {
>> + SWIZZLE_CONVERT(int8_t, int32_t, src);
>> + }
>> + break;
>> + default:
>> + assert(!"Invalid channel type combination");
>> + }
>> +}
>> +
>> +
>> +static void
>> +convert_ushort(void *void_dst, int num_dst_channels,
>> + const void *void_src, GLenum src_type, int
>> num_src_channels,
>> + const uint8_t swizzle[4], bool normalized, int count)
>> +{
>> + const uint16_t one = normalized ? UINT16_MAX : 1;
>> +
>> + switch (src_type) {
>> + case GL_FLOAT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint16_t, float, float_to_unorm(src, 16));
>> + } else {
>> + SWIZZLE_CONVERT(uint16_t, float, (src < 0) ? 0 : src);
>> + }
>> + break;
>> + case GL_HALF_FLOAT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_unorm(src, 16));
>> + } else {
>> + SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_uint(src));
>> + }
>> + break;
>> + case GL_UNSIGNED_BYTE:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint16_t, uint8_t, unorm_to_unorm(src, 8, 16));
>> + } else {
>> + SWIZZLE_CONVERT(uint16_t, uint8_t, src);
>> + }
>> + break;
>> + case GL_BYTE:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint16_t, int8_t, snorm_to_unorm(src, 8, 16));
>> + } else {
>> + SWIZZLE_CONVERT(uint16_t, int8_t, (src < 0) ? 0 : src);
>> + }
>> + break;
>> + case GL_UNSIGNED_SHORT:
>> + SWIZZLE_CONVERT(uint16_t, uint16_t, src);
>> + break;
>> + case GL_SHORT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint16_t, int16_t, snorm_to_unorm(src, 16, 16));
>> + } else {
>> + SWIZZLE_CONVERT(uint16_t, int16_t, (src < 0) ? 0 : src);
>> + }
>> + break;
>> + case GL_UNSIGNED_INT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint16_t, uint32_t, unorm_to_unorm(src, 32,
>> 16));
>> + } else {
>> + SWIZZLE_CONVERT(uint16_t, uint32_t, src);
>> + }
>> + break;
>> + case GL_INT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint16_t, int32_t, snorm_to_unorm(src, 32, 16));
>> + } else {
>> + SWIZZLE_CONVERT(uint16_t, int32_t, (src < 0) ? 0 : src);
>> + }
>> + break;
>> + default:
>> + assert(!"Invalid channel type combination");
>> + }
>> +}
>> +
>> +
>> +static void
>> +convert_short(void *void_dst, int num_dst_channels,
>> + const void *void_src, GLenum src_type, int
>> num_src_channels,
>> + const uint8_t swizzle[4], bool normalized, int count)
>> +{
>> + const int16_t one = normalized ? INT16_MAX : 1;
>> +
>> + switch (src_type) {
>> + case GL_FLOAT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint16_t, float, float_to_snorm(src, 16));
>> + } else {
>> + SWIZZLE_CONVERT(uint16_t, float, src);
>> + }
>> + break;
>> + case GL_HALF_FLOAT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_snorm(src, 16));
>> + } else {
>> + SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_half_to_float(src));
>> + }
>> + break;
>> + case GL_UNSIGNED_BYTE:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(int16_t, uint8_t, unorm_to_snorm(src, 8, 16));
>> + } else {
>> + SWIZZLE_CONVERT(int16_t, uint8_t, src);
>> + }
>> + break;
>> + case GL_BYTE:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(int16_t, int8_t, snorm_to_snorm(src, 8, 16));
>> + } else {
>> + SWIZZLE_CONVERT(int16_t, int8_t, src);
>> + }
>> + break;
>> + case GL_UNSIGNED_SHORT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(int16_t, uint16_t, unorm_to_snorm(src, 16, 16));
>> + } else {
>> + SWIZZLE_CONVERT(int16_t, uint16_t, src);
>> + }
>> + break;
>> + case GL_SHORT:
>> + SWIZZLE_CONVERT(int16_t, int16_t, src);
>> + break;
>> + case GL_UNSIGNED_INT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(int16_t, uint32_t, unorm_to_snorm(src, 32, 16));
>> + } else {
>> + SWIZZLE_CONVERT(int16_t, uint32_t, src);
>> + }
>> + break;
>> + case GL_INT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(int16_t, int32_t, snorm_to_snorm(src, 32, 16));
>> + } else {
>> + SWIZZLE_CONVERT(int16_t, int32_t, src);
>> + }
>> + break;
>> + default:
>> + assert(!"Invalid channel type combination");
>> + }
>> +}
>> +
>> +static void
>> +convert_uint(void *void_dst, int num_dst_channels,
>> + const void *void_src, GLenum src_type, int num_src_channels,
>> + const uint8_t swizzle[4], bool normalized, int count)
>> +{
>> + const uint32_t one = normalized ? UINT32_MAX : 1;
>> +
>> + switch (src_type) {
>> + case GL_FLOAT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint32_t, float, float_to_unorm(src, 32));
>> + } else {
>> + SWIZZLE_CONVERT(uint32_t, float, (src < 0) ? 0 : src);
>> + }
>> + break;
>> + case GL_HALF_FLOAT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_unorm(src, 32));
>> + } else {
>> + SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_uint(src));
>> + }
>> + break;
>> + case GL_UNSIGNED_BYTE:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint32_t, uint8_t, unorm_to_unorm(src, 8, 32));
>> + } else {
>> + SWIZZLE_CONVERT(uint32_t, uint8_t, src);
>> + }
>> + break;
>> + case GL_BYTE:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint32_t, int8_t, snorm_to_unorm(src, 8, 32));
>> + } else {
>> + SWIZZLE_CONVERT(uint32_t, int8_t, (src < 0) ? 0 : src);
>> + }
>> + break;
>> + case GL_UNSIGNED_SHORT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint32_t, uint16_t, unorm_to_unorm(src, 16,
>> 32));
>> + } else {
>> + SWIZZLE_CONVERT(uint32_t, uint16_t, src);
>> + }
>> + break;
>> + case GL_SHORT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint32_t, int16_t, snorm_to_unorm(src, 16, 32));
>> + } else {
>> + SWIZZLE_CONVERT(uint32_t, int16_t, (src < 0) ? 0 : src);
>> + }
>> + break;
>> + case GL_UNSIGNED_INT:
>> + SWIZZLE_CONVERT(uint32_t, uint32_t, src);
>> + break;
>> + case GL_INT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint32_t, int32_t, snorm_to_unorm(src, 32, 32));
>> + } else {
>> + SWIZZLE_CONVERT(uint32_t, int32_t, (src < 0) ? 0 : src);
>> + }
>> + break;
>> + default:
>> + assert(!"Invalid channel type combination");
>> + }
>> +}
>> +
>> +
>> +static void
>> +convert_int(void *void_dst, int num_dst_channels,
>> + const void *void_src, GLenum src_type, int num_src_channels,
>> + const uint8_t swizzle[4], bool normalized, int count)
>> +{
>> + const int32_t one = normalized ? INT32_MAX : 12;
>> +
>> + switch (src_type) {
>> + case GL_FLOAT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint32_t, float, float_to_snorm(src, 32));
>> + } else {
>> + SWIZZLE_CONVERT(uint32_t, float, src);
>> + }
>> + break;
>> + case GL_HALF_FLOAT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_snorm(src, 32));
>> + } else {
>> + SWIZZLE_CONVERT(uint32_t, uint16_t, _mesa_half_to_float(src));
>> + }
>> + break;
>> + case GL_UNSIGNED_BYTE:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(int32_t, uint8_t, unorm_to_snorm(src, 8, 32));
>> + } else {
>> + SWIZZLE_CONVERT(int32_t, uint8_t, src);
>> + }
>> + break;
>> + case GL_BYTE:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(int32_t, int8_t, snorm_to_snorm(src, 8, 32));
>> + } else {
>> + SWIZZLE_CONVERT(int32_t, int8_t, src);
>> + }
>> + break;
>> + case GL_UNSIGNED_SHORT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(int32_t, uint16_t, unorm_to_snorm(src, 16, 32));
>> + } else {
>> + SWIZZLE_CONVERT(int32_t, uint16_t, src);
>> + }
>> + break;
>> + case GL_SHORT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(int32_t, int16_t, snorm_to_snorm(src, 16, 32));
>> + } else {
>> + SWIZZLE_CONVERT(int32_t, int16_t, src);
>> + }
>> + break;
>> + case GL_UNSIGNED_INT:
>> + if (normalized) {
>> + SWIZZLE_CONVERT(int32_t, uint32_t, unorm_to_snorm(src, 32, 32));
>> + } else {
>> + SWIZZLE_CONVERT(int32_t, uint32_t, src);
>> + }
>> + break;
>> + case GL_INT:
>> + SWIZZLE_CONVERT(int32_t, int32_t, src);
>> + break;
>> + default:
>> + assert(!"Invalid channel type combination");
>> + }
>> +}
>> +
>>
>> /**
>> * Convert between array-based color formats.
>> @@ -478,499 +1003,44 @@ _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,
>> const uint8_t swizzle[4], bool normalized, int
>> count)
>> {
>> - int s, j;
>> - register uint8_t swizzle_x, swizzle_y, swizzle_z, swizzle_w;
>> -
>> if (swizzle_convert_try_memcpy(void_dst, dst_type, num_dst_channels,
>> void_src, src_type, num_src_channels,
>> swizzle, normalized, count))
>> return;
>>
>> - swizzle_x = swizzle[0];
>> - swizzle_y = swizzle[1];
>> - swizzle_z = swizzle[2];
>> - swizzle_w = swizzle[3];
>> -
>> switch (dst_type) {
>> case GL_FLOAT:
>> - {
>> - const float one = 1.0f;
>> - switch (src_type) {
>> - case GL_FLOAT:
>> - SWIZZLE_CONVERT(float, float, src)
>> - break;
>> - case GL_HALF_FLOAT:
>> - SWIZZLE_CONVERT(float, uint16_t, _mesa_half_to_float(src))
>> - break;
>> - case GL_UNSIGNED_BYTE:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(float, uint8_t, unorm_to_float(src, 8))
>> - } else {
>> - SWIZZLE_CONVERT(float, uint8_t, src)
>> - }
>> - break;
>> - case GL_BYTE:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(float, int8_t, snorm_to_float(src, 8))
>> - } else {
>> - SWIZZLE_CONVERT(float, int8_t, src)
>> - }
>> - break;
>> - case GL_UNSIGNED_SHORT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(float, uint16_t, unorm_to_float(src, 16))
>> - } else {
>> - SWIZZLE_CONVERT(float, uint16_t, src)
>> - }
>> - break;
>> - case GL_SHORT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(float, int16_t, snorm_to_float(src, 16))
>> - } else {
>> - SWIZZLE_CONVERT(float, int16_t, src)
>> - }
>> - break;
>> - case GL_UNSIGNED_INT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(float, uint32_t, unorm_to_float(src, 32))
>> - } else {
>> - SWIZZLE_CONVERT(float, uint32_t, src)
>> - }
>> - break;
>> - case GL_INT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(float, int32_t, snorm_to_float(src, 32))
>> - } else {
>> - SWIZZLE_CONVERT(float, int32_t, src)
>> - }
>> - break;
>> - default:
>> - assert(!"Invalid channel type combination");
>> - }
>> - }
>> - break;
>> + convert_float(void_dst, num_dst_channels, void_src, src_type,
>> + num_src_channels, swizzle, normalized, count);
>> + break;
>> case GL_HALF_FLOAT:
>> - {
>> - const uint16_t one = _mesa_float_to_half(1.0f);
>> - switch (src_type) {
>> - case GL_FLOAT:
>> - SWIZZLE_CONVERT(uint16_t, float, _mesa_float_to_half(src))
>> - break;
>> - case GL_HALF_FLOAT:
>> - SWIZZLE_CONVERT(uint16_t, uint16_t, src)
>> - break;
>> - case GL_UNSIGNED_BYTE:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint16_t, uint8_t, unorm_to_half(src, 8))
>> - } else {
>> - SWIZZLE_CONVERT(uint16_t, uint8_t, _mesa_float_to_half(src))
>> - }
>> - break;
>> - case GL_BYTE:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint16_t, int8_t, snorm_to_half(src, 8))
>> - } else {
>> - SWIZZLE_CONVERT(uint16_t, int8_t, _mesa_float_to_half(src))
>> - }
>> - break;
>> - case GL_UNSIGNED_SHORT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint16_t, uint16_t, unorm_to_half(src, 16))
>> - } else {
>> - SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_float_to_half(src))
>> - }
>> - break;
>> - case GL_SHORT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint16_t, int16_t, snorm_to_half(src, 16))
>> - } else {
>> - SWIZZLE_CONVERT(uint16_t, int16_t, _mesa_float_to_half(src))
>> - }
>> - break;
>> - case GL_UNSIGNED_INT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint16_t, uint32_t, unorm_to_half(src, 32))
>> - } else {
>> - SWIZZLE_CONVERT(uint16_t, uint32_t, _mesa_float_to_half(src))
>> - }
>> - break;
>> - case GL_INT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint16_t, int32_t, snorm_to_half(src, 32))
>> - } else {
>> - SWIZZLE_CONVERT(uint16_t, int32_t, _mesa_float_to_half(src))
>> - }
>> - break;
>> - default:
>> - assert(!"Invalid channel type combination");
>> - }
>> - }
>> - break;
>> + convert_half_float(void_dst, num_dst_channels, void_src, src_type,
>> + num_src_channels, swizzle, normalized, count);
>> + break;
>> case GL_UNSIGNED_BYTE:
>> - {
>> - const uint8_t one = normalized ? UINT8_MAX : 1;
>> - switch (src_type) {
>> - case GL_FLOAT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint8_t, float, float_to_unorm(src, 8))
>> - } else {
>> - SWIZZLE_CONVERT(uint8_t, float, (src < 0) ? 0 : src)
>> - }
>> - break;
>> - case GL_HALF_FLOAT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_unorm(src, 8))
>> - } else {
>> - SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_uint(src))
>> - }
>> - break;
>> - case GL_UNSIGNED_BYTE:
>> - SWIZZLE_CONVERT(uint8_t, uint8_t, src)
>> - break;
>> - case GL_BYTE:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint8_t, int8_t, snorm_to_unorm(src, 8, 8))
>> - } else {
>> - SWIZZLE_CONVERT(uint8_t, int8_t, (src < 0) ? 0 : src)
>> - }
>> - break;
>> - case GL_UNSIGNED_SHORT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint8_t, uint16_t, unorm_to_unorm(src, 16,
>> 8))
>> - } else {
>> - SWIZZLE_CONVERT(uint8_t, uint16_t, src)
>> - }
>> - break;
>> - case GL_SHORT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint8_t, int16_t, snorm_to_unorm(src, 16, 8))
>> - } else {
>> - SWIZZLE_CONVERT(uint8_t, int16_t, (src < 0) ? 0 : src)
>> - }
>> - break;
>> - case GL_UNSIGNED_INT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint8_t, uint32_t, unorm_to_unorm(src, 32,
>> 8))
>> - } else {
>> - SWIZZLE_CONVERT(uint8_t, uint32_t, src)
>> - }
>> - break;
>> - case GL_INT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint8_t, int32_t, snorm_to_unorm(src, 32, 8))
>> - } else {
>> - SWIZZLE_CONVERT(uint8_t, int32_t, (src < 0) ? 0 : src)
>> - }
>> - break;
>> - default:
>> - assert(!"Invalid channel type combination");
>> - }
>> - }
>> - break;
>> + convert_ubyte(void_dst, num_dst_channels, void_src, src_type,
>> + num_src_channels, swizzle, normalized, count);
>> + break;
>> case GL_BYTE:
>> - {
>> - const int8_t one = normalized ? INT8_MAX : 1;
>> - switch (src_type) {
>> - case GL_FLOAT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint8_t, float, float_to_snorm(src, 8))
>> - } else {
>> - SWIZZLE_CONVERT(uint8_t, float, src)
>> - }
>> - break;
>> - case GL_HALF_FLOAT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_snorm(src, 8))
>> - } else {
>> - SWIZZLE_CONVERT(uint8_t, uint16_t, _mesa_half_to_float(src))
>> - }
>> - break;
>> - case GL_UNSIGNED_BYTE:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(int8_t, uint8_t, unorm_to_snorm(src, 8, 8))
>> - } else {
>> - SWIZZLE_CONVERT(int8_t, uint8_t, src)
>> - }
>> - break;
>> - case GL_BYTE:
>> - SWIZZLE_CONVERT(int8_t, int8_t, src)
>> - break;
>> - case GL_UNSIGNED_SHORT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(int8_t, uint16_t, unorm_to_snorm(src, 16, 8))
>> - } else {
>> - SWIZZLE_CONVERT(int8_t, uint16_t, src)
>> - }
>> - break;
>> - case GL_SHORT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(int8_t, int16_t, snorm_to_snorm(src, 16, 8))
>> - } else {
>> - SWIZZLE_CONVERT(int8_t, int16_t, src)
>> - }
>> - break;
>> - case GL_UNSIGNED_INT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(int8_t, uint32_t, unorm_to_snorm(src, 32, 8))
>> - } else {
>> - SWIZZLE_CONVERT(int8_t, uint32_t, src)
>> - }
>> - break;
>> - case GL_INT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(int8_t, int32_t, snorm_to_snorm(src, 32, 8))
>> - } else {
>> - SWIZZLE_CONVERT(int8_t, int32_t, src)
>> - }
>> - break;
>> - default:
>> - assert(!"Invalid channel type combination");
>> - }
>> - }
>> - break;
>> + convert_byte(void_dst, num_dst_channels, void_src, src_type,
>> + num_src_channels, swizzle, normalized, count);
>> + break;
>> case GL_UNSIGNED_SHORT:
>> - {
>> - const uint16_t one = normalized ? UINT16_MAX : 1;
>> - switch (src_type) {
>> - case GL_FLOAT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint16_t, float, float_to_unorm(src, 16))
>> - } else {
>> - SWIZZLE_CONVERT(uint16_t, float, (src < 0) ? 0 : src)
>> - }
>> - break;
>> - case GL_HALF_FLOAT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_unorm(src, 16))
>> - } else {
>> - SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_uint(src))
>> - }
>> - break;
>> - case GL_UNSIGNED_BYTE:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint16_t, uint8_t, unorm_to_unorm(src, 8,
>> 16))
>> - } else {
>> - SWIZZLE_CONVERT(uint16_t, uint8_t, src)
>> - }
>> - break;
>> - case GL_BYTE:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint16_t, int8_t, snorm_to_unorm(src, 8, 16))
>> - } else {
>> - SWIZZLE_CONVERT(uint16_t, int8_t, (src < 0) ? 0 : src)
>> - }
>> - break;
>> - case GL_UNSIGNED_SHORT:
>> - SWIZZLE_CONVERT(uint16_t, uint16_t, src)
>> - break;
>> - case GL_SHORT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint16_t, int16_t, snorm_to_unorm(src, 16,
>> 16))
>> - } else {
>> - SWIZZLE_CONVERT(uint16_t, int16_t, (src < 0) ? 0 : src)
>> - }
>> - break;
>> - case GL_UNSIGNED_INT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint16_t, uint32_t, unorm_to_unorm(src, 32,
>> 16))
>> - } else {
>> - SWIZZLE_CONVERT(uint16_t, uint32_t, src)
>> - }
>> - break;
>> - case GL_INT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint16_t, int32_t, snorm_to_unorm(src, 32,
>> 16))
>> - } else {
>> - SWIZZLE_CONVERT(uint16_t, int32_t, (src < 0) ? 0 : src)
>> - }
>> - break;
>> - default:
>> - assert(!"Invalid channel type combination");
>> - }
>> - }
>> - break;
>> + convert_ushort(void_dst, num_dst_channels, void_src, src_type,
>> + num_src_channels, swizzle, normalized, count);
>> + break;
>> case GL_SHORT:
>> - {
>> - const int16_t one = normalized ? INT16_MAX : 1;
>> - switch (src_type) {
>> - case GL_FLOAT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint16_t, float, float_to_snorm(src, 16))
>> - } else {
>> - SWIZZLE_CONVERT(uint16_t, float, src)
>> - }
>> - break;
>> - case GL_HALF_FLOAT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_snorm(src, 16))
>> - } else {
>> - SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_half_to_float(src))
>> - }
>> - break;
>> - case GL_UNSIGNED_BYTE:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(int16_t, uint8_t, unorm_to_snorm(src, 8, 16))
>> - } else {
>> - SWIZZLE_CONVERT(int16_t, uint8_t, src)
>> - }
>> - break;
>> - case GL_BYTE:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(int16_t, int8_t, snorm_to_snorm(src, 8, 16))
>> - } else {
>> - SWIZZLE_CONVERT(int16_t, int8_t, src)
>> - }
>> - break;
>> - case GL_UNSIGNED_SHORT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(int16_t, uint16_t, unorm_to_snorm(src, 16,
>> 16))
>> - } else {
>> - SWIZZLE_CONVERT(int16_t, uint16_t, src)
>> - }
>> - break;
>> - case GL_SHORT:
>> - SWIZZLE_CONVERT(int16_t, int16_t, src)
>> - break;
>> - case GL_UNSIGNED_INT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(int16_t, uint32_t, unorm_to_snorm(src, 32,
>> 16))
>> - } else {
>> - SWIZZLE_CONVERT(int16_t, uint32_t, src)
>> - }
>> - break;
>> - case GL_INT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(int16_t, int32_t, snorm_to_snorm(src, 32,
>> 16))
>> - } else {
>> - SWIZZLE_CONVERT(int16_t, int32_t, src)
>> - }
>> - break;
>> - default:
>> - assert(!"Invalid channel type combination");
>> - }
>> - }
>> - break;
>> + convert_short(void_dst, num_dst_channels, void_src, src_type,
>> + num_src_channels, swizzle, normalized, count);
>> + break;
>> case GL_UNSIGNED_INT:
>> - {
>> - const uint32_t one = normalized ? UINT32_MAX : 1;
>> - switch (src_type) { case GL_FLOAT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint32_t, float, float_to_unorm(src, 32))
>> - } else {
>> - SWIZZLE_CONVERT(uint32_t, float, (src < 0) ? 0 : src)
>> - }
>> - break;
>> - case GL_HALF_FLOAT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_unorm(src, 32))
>> - } else {
>> - SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_uint(src))
>> - }
>> - break;
>> - case GL_UNSIGNED_BYTE:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint32_t, uint8_t, unorm_to_unorm(src, 8,
>> 32))
>> - } else {
>> - SWIZZLE_CONVERT(uint32_t, uint8_t, src)
>> - }
>> - break;
>> - case GL_BYTE:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint32_t, int8_t, snorm_to_unorm(src, 8, 32))
>> - } else {
>> - SWIZZLE_CONVERT(uint32_t, int8_t, (src < 0) ? 0 : src)
>> - }
>> - break;
>> - case GL_UNSIGNED_SHORT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint32_t, uint16_t, unorm_to_unorm(src, 16,
>> 32))
>> - } else {
>> - SWIZZLE_CONVERT(uint32_t, uint16_t, src)
>> - }
>> - break;
>> - case GL_SHORT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint32_t, int16_t, snorm_to_unorm(src, 16,
>> 32))
>> - } else {
>> - SWIZZLE_CONVERT(uint32_t, int16_t, (src < 0) ? 0 : src)
>> - }
>> - break;
>> - case GL_UNSIGNED_INT:
>> - SWIZZLE_CONVERT(uint32_t, uint32_t, src)
>> - break;
>> - case GL_INT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint32_t, int32_t, snorm_to_unorm(src, 32,
>> 32))
>> - } else {
>> - SWIZZLE_CONVERT(uint32_t, int32_t, (src < 0) ? 0 : src)
>> - }
>> - break;
>> - default:
>> - assert(!"Invalid channel type combination");
>> - }
>> - }
>> - break;
>> + convert_uint(void_dst, num_dst_channels, void_src, src_type,
>> + num_src_channels, swizzle, normalized, count);
>> + break;
>> case GL_INT:
>> - {
>> - const int32_t one = normalized ? INT32_MAX : 1;
>> - switch (src_type) {
>> - case GL_FLOAT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint32_t, float, float_to_snorm(src, 32))
>> - } else {
>> - SWIZZLE_CONVERT(uint32_t, float, src)
>> - }
>> - break;
>> - case GL_HALF_FLOAT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_snorm(src, 32))
>> - } else {
>> - SWIZZLE_CONVERT(uint32_t, uint16_t, _mesa_half_to_float(src))
>> - }
>> - break;
>> - case GL_UNSIGNED_BYTE:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(int32_t, uint8_t, unorm_to_snorm(src, 8, 32))
>> - } else {
>> - SWIZZLE_CONVERT(int32_t, uint8_t, src)
>> - }
>> - break;
>> - case GL_BYTE:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(int32_t, int8_t, snorm_to_snorm(src, 8, 32))
>> - } else {
>> - SWIZZLE_CONVERT(int32_t, int8_t, src)
>> - }
>> - break;
>> - case GL_UNSIGNED_SHORT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(int32_t, uint16_t, unorm_to_snorm(src, 16,
>> 32))
>> - } else {
>> - SWIZZLE_CONVERT(int32_t, uint16_t, src)
>> - }
>> - break;
>> - case GL_SHORT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(int32_t, int16_t, snorm_to_snorm(src, 16,
>> 32))
>> - } else {
>> - SWIZZLE_CONVERT(int32_t, int16_t, src)
>> - }
>> - break;
>> - case GL_UNSIGNED_INT:
>> - if (normalized) {
>> - SWIZZLE_CONVERT(int32_t, uint32_t, unorm_to_snorm(src, 32,
>> 32))
>> - } else {
>> - SWIZZLE_CONVERT(int32_t, uint32_t, src)
>> - }
>> - break;
>> - case GL_INT:
>> - SWIZZLE_CONVERT(int32_t, int32_t, src)
>> - break;
>> - default:
>> - assert(!"Invalid channel type combination");
>> - }
>> - }
>> - break;
>> + convert_int(void_dst, num_dst_channels, void_src, src_type,
>> + num_src_channels, swizzle, normalized, count);
>> + break;
>> default:
>> assert(!"Invalid channel type");
>> }
>> --
>> 1.7.10.4
>>
>> _______________________________________________
>> mesa-dev mailing list
>> mesa-dev@lists.freedesktop.org
>> http://lists.freedesktop.org/mailman/listinfo/mesa-dev
>>
>
>
_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
http://lists.freedesktop.org/mailman/listinfo/mesa-dev
