//
// Copyright (c) 2017 The Khronos Group Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "conversions.h"
#include <cinttypes>
#include <limits.h>
#include <time.h>
#include <assert.h>
#include "mt19937.h"
#include "compat.h"

#if defined(__SSE__) || defined(_MSC_VER)
#include <xmmintrin.h>
#endif
#if defined(__SSE2__) || defined(_MSC_VER)
#include <emmintrin.h>
#endif

void print_type_to_string(ExplicitType type, void *data, char *string)
{
    switch (type)
    {
        case kBool:
            if (*(char *)data)
                sprintf(string, "true");
            else
                sprintf(string, "false");
            return;
        case kChar: sprintf(string, "%d", (int)*((cl_char *)data)); return;
        case kUChar:
        case kUnsignedChar:
            sprintf(string, "%u", (int)*((cl_uchar *)data));
            return;
        case kShort: sprintf(string, "%d", (int)*((cl_short *)data)); return;
        case kUShort:
        case kUnsignedShort:
            sprintf(string, "%u", (int)*((cl_ushort *)data));
            return;
        case kInt: sprintf(string, "%d", *((cl_int *)data)); return;
        case kUInt:
        case kUnsignedInt: sprintf(string, "%u", *((cl_uint *)data)); return;
        case kLong: sprintf(string, "%" PRId64 "", *((cl_long *)data)); return;
        case kULong:
        case kUnsignedLong:
            sprintf(string, "%" PRIu64 "", *((cl_ulong *)data));
            return;
        case kFloat: sprintf(string, "%f", *((cl_float *)data)); return;
        case kHalf: sprintf(string, "half"); return;
        case kDouble: sprintf(string, "%g", *((cl_double *)data)); return;
        default: sprintf(string, "INVALID"); return;
    }
}

size_t get_explicit_type_size(ExplicitType type)
{
    /* Quick method to avoid branching: make sure the following array matches
     * the Enum order */
    static size_t sExplicitTypeSizes[] = {
        sizeof(cl_bool),   sizeof(cl_char),  sizeof(cl_uchar),
        sizeof(cl_uchar),  sizeof(cl_short), sizeof(cl_ushort),
        sizeof(cl_ushort), sizeof(cl_int),   sizeof(cl_uint),
        sizeof(cl_uint),   sizeof(cl_long),  sizeof(cl_ulong),
        sizeof(cl_ulong),  sizeof(cl_float), sizeof(cl_half),
        sizeof(cl_double)
    };

    return sExplicitTypeSizes[type];
}

const char *get_explicit_type_name(ExplicitType type)
{
    /* Quick method to avoid branching: make sure the following array matches
     * the Enum order */
    static const char *sExplicitTypeNames[] = {
        "bool",           "char",  "uchar", "unsigned char", "short", "ushort",
        "unsigned short", "int",   "uint",  "unsigned int",  "long",  "ulong",
        "unsigned long",  "float", "half",  "double"
    };

    return sExplicitTypeNames[type];
}

static long lrintf_clamped(float f);
static long lrintf_clamped(float f)
{
    static const float magic[2] = { MAKE_HEX_FLOAT(0x1.0p23f, 0x1, 23),
                                    -MAKE_HEX_FLOAT(0x1.0p23f, 0x1, 23) };

    if (f >= -(float)LONG_MIN) return LONG_MAX;

    if (f <= (float)LONG_MIN) return LONG_MIN;

    // Round fractional values to integer in round towards nearest mode
    if (fabsf(f) < MAKE_HEX_FLOAT(0x1.0p23f, 0x1, 23))
    {
        volatile float x = f;
        float magicVal = magic[f < 0];

#if defined(__SSE__) || defined(_WIN32)
        // Defeat x87 based arithmetic, which cant do FTZ, and will round this
        // incorrectly
        __m128 v = _mm_set_ss(x);
        __m128 m = _mm_set_ss(magicVal);
        v = _mm_add_ss(v, m);
        v = _mm_sub_ss(v, m);
        _mm_store_ss((float *)&x, v);
#else
        x += magicVal;
        x -= magicVal;
#endif
        f = x;
    }

    return (long)f;
}

static long lrint_clamped(double f);
static long lrint_clamped(double f)
{
    static const double magic[2] = { MAKE_HEX_DOUBLE(0x1.0p52, 0x1LL, 52),
                                     MAKE_HEX_DOUBLE(-0x1.0p52, -0x1LL, 52) };

    if (sizeof(long) > 4)
    {
        if (f >= -(double)LONG_MIN) return LONG_MAX;
    }
    else
    {
        if (f >= LONG_MAX) return LONG_MAX;
    }

    if (f <= (double)LONG_MIN) return LONG_MIN;

    // Round fractional values to integer in round towards nearest mode
    if (fabs(f) < MAKE_HEX_DOUBLE(0x1.0p52, 0x1LL, 52))
    {
        volatile double x = f;
        double magicVal = magic[f < 0];
#if defined(__SSE2__) || (defined(_MSC_VER))
        // Defeat x87 based arithmetic, which cant do FTZ, and will round this
        // incorrectly
        __m128d v = _mm_set_sd(x);
        __m128d m = _mm_set_sd(magicVal);
        v = _mm_add_sd(v, m);
        v = _mm_sub_sd(v, m);
        _mm_store_sd((double *)&x, v);
#else
        x += magicVal;
        x -= magicVal;
#endif
        f = x;
    }

    return (long)f;
}


typedef cl_long Long;
typedef cl_ulong ULong;

static ULong sUpperLimits[kNumExplicitTypes] = {
    0,
    127,
    255,
    255,
    32767,
    65535,
    65535,
    0x7fffffffLL,
    0xffffffffLL,
    0xffffffffLL,
    0x7fffffffffffffffLL,
    0xffffffffffffffffULL,
    0xffffffffffffffffULL,
    0,
    0
}; // Last two values aren't stored here

static Long sLowerLimits[kNumExplicitTypes] = {
    -1,
    -128,
    0,
    0,
    -32768,
    0,
    0,
    (Long)0xffffffff80000000LL,
    0,
    0,
    (Long)0x8000000000000000LL,
    0,
    0,
    0,
    0
}; // Last two values aren't stored here

#define BOOL_CASE(inType)                                                      \
    case kBool:                                                                \
        boolPtr = (bool *)outRaw;                                              \
        *boolPtr = (*inType##Ptr) != 0 ? true : false;                         \
        break;

#define SIMPLE_CAST_CASE(inType, outEnum, outType)                             \
    case outEnum:                                                              \
        outType##Ptr = (outType *)outRaw;                                      \
        *outType##Ptr = (outType)(*inType##Ptr);                               \
        break;

// Sadly, the ULong downcasting cases need a separate #define to get rid of
// signed/unsigned comparison warnings
#define DOWN_CAST_CASE(inType, outEnum, outType, sat)                          \
    case outEnum:                                                              \
        outType##Ptr = (outType *)outRaw;                                      \
        if (sat)                                                               \
        {                                                                      \
            if ((sLowerLimits[outEnum] < 0                                     \
                 && *inType##Ptr > (Long)sUpperLimits[outEnum])                \
                || (sLowerLimits[outEnum] == 0                                 \
                    && (ULong)*inType##Ptr > sUpperLimits[outEnum]))           \
                *outType##Ptr = (outType)sUpperLimits[outEnum];                \
            else if (*inType##Ptr < sLowerLimits[outEnum])                     \
                *outType##Ptr = (outType)sLowerLimits[outEnum];                \
            else                                                               \
                *outType##Ptr = (outType)*inType##Ptr;                         \
        }                                                                      \
        else                                                                   \
        {                                                                      \
            *outType##Ptr = (outType)(                                         \
                *inType##Ptr                                                   \
                & (0xffffffffffffffffLL >> (64 - (sizeof(outType) * 8))));     \
        }                                                                      \
        break;

#define U_DOWN_CAST_CASE(inType, outEnum, outType, sat)                        \
    case outEnum:                                                              \
        outType##Ptr = (outType *)outRaw;                                      \
        if (sat)                                                               \
        {                                                                      \
            if ((ULong)*inType##Ptr > sUpperLimits[outEnum])                   \
                *outType##Ptr = (outType)sUpperLimits[outEnum];                \
            else                                                               \
                *outType##Ptr = (outType)*inType##Ptr;                         \
        }                                                                      \
        else                                                                   \
        {                                                                      \
            *outType##Ptr = (outType)(                                         \
                *inType##Ptr                                                   \
                & (0xffffffffffffffffLL >> (64 - (sizeof(outType) * 8))));     \
        }                                                                      \
        break;

#define TO_FLOAT_CASE(inType)                                                  \
    case kFloat:                                                               \
        floatPtr = (float *)outRaw;                                            \
        *floatPtr = (float)(*inType##Ptr);                                     \
        break;
#define TO_DOUBLE_CASE(inType)                                                 \
    case kDouble:                                                              \
        doublePtr = (double *)outRaw;                                          \
        *doublePtr = (double)(*inType##Ptr);                                   \
        break;


/* Note: we use lrintf here to force the rounding instead of whatever the
 * processor's current rounding mode is */
#define FLOAT_ROUND_TO_NEAREST_CASE(outEnum, outType)                          \
    case outEnum:                                                              \
        outType##Ptr = (outType *)outRaw;                                      \
        *outType##Ptr = (outType)lrintf_clamped(*floatPtr);                    \
        break;

#define FLOAT_ROUND_CASE(outEnum, outType, rounding, sat)                      \
    case outEnum: {                                                            \
        outType##Ptr = (outType *)outRaw;                                      \
        /* Get the tens digit */                                               \
        Long wholeValue = (Long)*floatPtr;                                     \
        float largeRemainder = (*floatPtr - (float)wholeValue) * 10.f;         \
        /* What do we do based on that? */                                     \
        if (rounding == kRoundToEven)                                          \
        {                                                                      \
            if (wholeValue & 1LL) /*between 1 and 1.99 */                      \
                wholeValue += 1LL; /* round up to even */                      \
        }                                                                      \
        else if (rounding == kRoundToZero)                                     \
        {                                                                      \
            /* Nothing to do, round-to-zero is what C casting does */          \
        }                                                                      \
        else if (rounding == kRoundToPosInf)                                   \
        {                                                                      \
            /* Only positive numbers are wrong */                              \
            if (largeRemainder != 0.f && wholeValue >= 0) wholeValue++;        \
        }                                                                      \
        else if (rounding == kRoundToNegInf)                                   \
        {                                                                      \
            /* Only negative numbers are off */                                \
            if (largeRemainder != 0.f && wholeValue < 0) wholeValue--;         \
        }                                                                      \
        else                                                                   \
        { /* Default is round-to-nearest */                                    \
            wholeValue = (Long)lrintf_clamped(*floatPtr);                      \
        }                                                                      \
        /* Now apply saturation rules */                                       \
        if (sat)                                                               \
        {                                                                      \
            if ((sLowerLimits[outEnum] < 0                                     \
                 && wholeValue > (Long)sUpperLimits[outEnum])                  \
                || (sLowerLimits[outEnum] == 0                                 \
                    && (ULong)wholeValue > sUpperLimits[outEnum]))             \
                *outType##Ptr = (outType)sUpperLimits[outEnum];                \
            else if (wholeValue < sLowerLimits[outEnum])                       \
                *outType##Ptr = (outType)sLowerLimits[outEnum];                \
            else                                                               \
                *outType##Ptr = (outType)wholeValue;                           \
        }                                                                      \
        else                                                                   \
        {                                                                      \
            *outType##Ptr = (outType)(                                         \
                wholeValue                                                     \
                & (0xffffffffffffffffLL >> (64 - (sizeof(outType) * 8))));     \
        }                                                                      \
    }                                                                          \
    break;

#define DOUBLE_ROUND_CASE(outEnum, outType, rounding, sat)                     \
    case outEnum: {                                                            \
        outType##Ptr = (outType *)outRaw;                                      \
        /* Get the tens digit */                                               \
        Long wholeValue = (Long)*doublePtr;                                    \
        double largeRemainder = (*doublePtr - (double)wholeValue) * 10.0;      \
        /* What do we do based on that? */                                     \
        if (rounding == kRoundToEven)                                          \
        {                                                                      \
            if (wholeValue & 1LL) /*between 1 and 1.99 */                      \
                wholeValue += 1LL; /* round up to even */                      \
        }                                                                      \
        else if (rounding == kRoundToZero)                                     \
        {                                                                      \
            /* Nothing to do, round-to-zero is what C casting does */          \
        }                                                                      \
        else if (rounding == kRoundToPosInf)                                   \
        {                                                                      \
            /* Only positive numbers are wrong */                              \
            if (largeRemainder != 0.0 && wholeValue >= 0) wholeValue++;        \
        }                                                                      \
        else if (rounding == kRoundToNegInf)                                   \
        {                                                                      \
            /* Only negative numbers are off */                                \
            if (largeRemainder != 0.0 && wholeValue < 0) wholeValue--;         \
        }                                                                      \
        else                                                                   \
        { /* Default is round-to-nearest */                                    \
            wholeValue = (Long)lrint_clamped(*doublePtr);                      \
        }                                                                      \
        /* Now apply saturation rules */                                       \
        if (sat)                                                               \
        {                                                                      \
            if ((sLowerLimits[outEnum] < 0                                     \
                 && wholeValue > (Long)sUpperLimits[outEnum])                  \
                || (sLowerLimits[outEnum] == 0                                 \
                    && (ULong)wholeValue > sUpperLimits[outEnum]))             \
                *outType##Ptr = (outType)sUpperLimits[outEnum];                \
            else if (wholeValue < sLowerLimits[outEnum])                       \
                *outType##Ptr = (outType)sLowerLimits[outEnum];                \
            else                                                               \
                *outType##Ptr = (outType)wholeValue;                           \
        }                                                                      \
        else                                                                   \
        {                                                                      \
            *outType##Ptr = (outType)(                                         \
                wholeValue                                                     \
                & (0xffffffffffffffffLL >> (64 - (sizeof(outType) * 8))));     \
        }                                                                      \
    }                                                                          \
    break;

typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;

void convert_explicit_value(void *inRaw, void *outRaw, ExplicitType inType,
                            bool saturate, RoundingType roundType,
                            ExplicitType outType)
{
    bool *boolPtr;
    char *charPtr;
    uchar *ucharPtr;
    short *shortPtr;
    ushort *ushortPtr;
    int *intPtr;
    uint *uintPtr;
    Long *LongPtr;
    ULong *ULongPtr;
    float *floatPtr;
    double *doublePtr;


    switch (inType)
    {
        case kBool:
            boolPtr = (bool *)inRaw;
            switch (outType)
            {
                case kBool:
                    memcpy(outRaw, inRaw, get_explicit_type_size(inType));
                    break;

                case kChar:
                case kUChar:
                case kUnsignedChar:
                case kShort:
                case kUShort:
                case kUnsignedShort:
                case kInt:
                case kUInt:
                case kUnsignedInt:
                case kLong:
                case kULong:
                case kUnsignedLong:
                    memset(outRaw, *boolPtr ? 0xff : 0,
                           get_explicit_type_size(outType));
                    break;

                case kFloat:
                    floatPtr = (float *)outRaw;
                    *floatPtr = (*boolPtr) ? -1.f : 0.f;
                    break;
                case kDouble:
                    doublePtr = (double *)outRaw;
                    *doublePtr = (*boolPtr) ? -1.0 : 0.0;
                    break;
                default:
                    log_error("ERROR: Invalid type given to "
                              "convert_explicit_value!!\n");
                    break;
            }
            break;

        case kChar:
            charPtr = (char *)inRaw;
            switch (outType)
            {
                BOOL_CASE(char)

                case kChar:
                    memcpy(outRaw, inRaw, get_explicit_type_size(inType));
                    break;

                    DOWN_CAST_CASE(char, kUChar, uchar, saturate)
                    SIMPLE_CAST_CASE(char, kUnsignedChar, uchar)
                    SIMPLE_CAST_CASE(char, kShort, short)
                    SIMPLE_CAST_CASE(char, kUShort, ushort)
                    SIMPLE_CAST_CASE(char, kUnsignedShort, ushort)
                    SIMPLE_CAST_CASE(char, kInt, int)
                    SIMPLE_CAST_CASE(char, kUInt, uint)
                    SIMPLE_CAST_CASE(char, kUnsignedInt, uint)
                    SIMPLE_CAST_CASE(char, kLong, Long)
                    SIMPLE_CAST_CASE(char, kULong, ULong)
                    SIMPLE_CAST_CASE(char, kUnsignedLong, ULong)

                    TO_FLOAT_CASE(char)
                    TO_DOUBLE_CASE(char)

                default:
                    log_error("ERROR: Invalid type given to "
                              "convert_explicit_value!!\n");
                    break;
            }
            break;

        case kUChar:
            ucharPtr = (uchar *)inRaw;
            switch (outType)
            {
                BOOL_CASE(uchar)

                case kUChar:
                case kUnsignedChar:
                    memcpy(outRaw, inRaw, get_explicit_type_size(inType));
                    break;

                    DOWN_CAST_CASE(uchar, kChar, char, saturate)
                    SIMPLE_CAST_CASE(uchar, kShort, short)
                    SIMPLE_CAST_CASE(uchar, kUShort, ushort)
                    SIMPLE_CAST_CASE(uchar, kUnsignedShort, ushort)
                    SIMPLE_CAST_CASE(uchar, kInt, int)
                    SIMPLE_CAST_CASE(uchar, kUInt, uint)
                    SIMPLE_CAST_CASE(uchar, kUnsignedInt, uint)
                    SIMPLE_CAST_CASE(uchar, kLong, Long)
                    SIMPLE_CAST_CASE(uchar, kULong, ULong)
                    SIMPLE_CAST_CASE(uchar, kUnsignedLong, ULong)

                    TO_FLOAT_CASE(uchar)
                    TO_DOUBLE_CASE(uchar)

                default:
                    log_error("ERROR: Invalid type given to "
                              "convert_explicit_value!!\n");
                    break;
            }
            break;

        case kUnsignedChar:
            ucharPtr = (uchar *)inRaw;
            switch (outType)
            {
                BOOL_CASE(uchar)

                case kUChar:
                case kUnsignedChar:
                    memcpy(outRaw, inRaw, get_explicit_type_size(inType));
                    break;

                    DOWN_CAST_CASE(uchar, kChar, char, saturate)
                    SIMPLE_CAST_CASE(uchar, kShort, short)
                    SIMPLE_CAST_CASE(uchar, kUShort, ushort)
                    SIMPLE_CAST_CASE(uchar, kUnsignedShort, ushort)
                    SIMPLE_CAST_CASE(uchar, kInt, int)
                    SIMPLE_CAST_CASE(uchar, kUInt, uint)
                    SIMPLE_CAST_CASE(uchar, kUnsignedInt, uint)
                    SIMPLE_CAST_CASE(uchar, kLong, Long)
                    SIMPLE_CAST_CASE(uchar, kULong, ULong)
                    SIMPLE_CAST_CASE(uchar, kUnsignedLong, ULong)

                    TO_FLOAT_CASE(uchar)
                    TO_DOUBLE_CASE(uchar)

                default:
                    log_error("ERROR: Invalid type given to "
                              "convert_explicit_value!!\n");
                    break;
            }
            break;

        case kShort:
            shortPtr = (short *)inRaw;
            switch (outType)
            {
                BOOL_CASE(short)

                case kShort:
                    memcpy(outRaw, inRaw, get_explicit_type_size(inType));
                    break;

                    DOWN_CAST_CASE(short, kChar, char, saturate)
                    DOWN_CAST_CASE(short, kUChar, uchar, saturate)
                    DOWN_CAST_CASE(short, kUnsignedChar, uchar, saturate)
                    DOWN_CAST_CASE(short, kUShort, ushort, saturate)
                    DOWN_CAST_CASE(short, kUnsignedShort, ushort, saturate)
                    SIMPLE_CAST_CASE(short, kInt, int)
                    SIMPLE_CAST_CASE(short, kUInt, uint)
                    SIMPLE_CAST_CASE(short, kUnsignedInt, uint)
                    SIMPLE_CAST_CASE(short, kLong, Long)
                    SIMPLE_CAST_CASE(short, kULong, ULong)
                    SIMPLE_CAST_CASE(short, kUnsignedLong, ULong)

                    TO_FLOAT_CASE(short)
                    TO_DOUBLE_CASE(short)

                default:
                    log_error("ERROR: Invalid type given to "
                              "convert_explicit_value!!\n");
                    break;
            }
            break;

        case kUShort:
            ushortPtr = (ushort *)inRaw;
            switch (outType)
            {
                BOOL_CASE(ushort)

                case kUShort:
                case kUnsignedShort:
                    memcpy(outRaw, inRaw, get_explicit_type_size(inType));
                    break;

                    DOWN_CAST_CASE(ushort, kChar, char, saturate)
                    DOWN_CAST_CASE(ushort, kUChar, uchar, saturate)
                    DOWN_CAST_CASE(ushort, kUnsignedChar, uchar, saturate)
                    DOWN_CAST_CASE(ushort, kShort, short, saturate)
                    SIMPLE_CAST_CASE(ushort, kInt, int)
                    SIMPLE_CAST_CASE(ushort, kUInt, uint)
                    SIMPLE_CAST_CASE(ushort, kUnsignedInt, uint)
                    SIMPLE_CAST_CASE(ushort, kLong, Long)
                    SIMPLE_CAST_CASE(ushort, kULong, ULong)
                    SIMPLE_CAST_CASE(ushort, kUnsignedLong, ULong)

                    TO_FLOAT_CASE(ushort)
                    TO_DOUBLE_CASE(ushort)

                default:
                    log_error("ERROR: Invalid type given to "
                              "convert_explicit_value!!\n");
                    break;
            }
            break;

        case kUnsignedShort:
            ushortPtr = (ushort *)inRaw;
            switch (outType)
            {
                BOOL_CASE(ushort)

                case kUShort:
                case kUnsignedShort:
                    memcpy(outRaw, inRaw, get_explicit_type_size(inType));
                    break;

                    DOWN_CAST_CASE(ushort, kChar, char, saturate)
                    DOWN_CAST_CASE(ushort, kUChar, uchar, saturate)
                    DOWN_CAST_CASE(ushort, kUnsignedChar, uchar, saturate)
                    DOWN_CAST_CASE(ushort, kShort, short, saturate)
                    SIMPLE_CAST_CASE(ushort, kInt, int)
                    SIMPLE_CAST_CASE(ushort, kUInt, uint)
                    SIMPLE_CAST_CASE(ushort, kUnsignedInt, uint)
                    SIMPLE_CAST_CASE(ushort, kLong, Long)
                    SIMPLE_CAST_CASE(ushort, kULong, ULong)
                    SIMPLE_CAST_CASE(ushort, kUnsignedLong, ULong)

                    TO_FLOAT_CASE(ushort)
                    TO_DOUBLE_CASE(ushort)

                default:
                    log_error("ERROR: Invalid type given to "
                              "convert_explicit_value!!\n");
                    break;
            }
            break;

        case kInt:
            intPtr = (int *)inRaw;
            switch (outType)
            {
                BOOL_CASE(int)

                case kInt:
                    memcpy(outRaw, inRaw, get_explicit_type_size(inType));
                    break;

                    DOWN_CAST_CASE(int, kChar, char, saturate)
                    DOWN_CAST_CASE(int, kUChar, uchar, saturate)
                    DOWN_CAST_CASE(int, kUnsignedChar, uchar, saturate)
                    DOWN_CAST_CASE(int, kShort, short, saturate)
                    DOWN_CAST_CASE(int, kUShort, ushort, saturate)
                    DOWN_CAST_CASE(int, kUnsignedShort, ushort, saturate)
                    DOWN_CAST_CASE(int, kUInt, uint, saturate)
                    DOWN_CAST_CASE(int, kUnsignedInt, uint, saturate)
                    SIMPLE_CAST_CASE(int, kLong, Long)
                    SIMPLE_CAST_CASE(int, kULong, ULong)
                    SIMPLE_CAST_CASE(int, kUnsignedLong, ULong)

                    TO_FLOAT_CASE(int)
                    TO_DOUBLE_CASE(int)

                default:
                    log_error("ERROR: Invalid type given to "
                              "convert_explicit_value!!\n");
                    break;
            }
            break;

        case kUInt:
            uintPtr = (uint *)inRaw;
            switch (outType)
            {
                BOOL_CASE(uint)

                case kUInt:
                case kUnsignedInt:
                    memcpy(outRaw, inRaw, get_explicit_type_size(inType));
                    break;

                    DOWN_CAST_CASE(uint, kChar, char, saturate)
                    DOWN_CAST_CASE(uint, kUChar, uchar, saturate)
                    DOWN_CAST_CASE(uint, kUnsignedChar, uchar, saturate)
                    DOWN_CAST_CASE(uint, kShort, short, saturate)
                    DOWN_CAST_CASE(uint, kUShort, ushort, saturate)
                    DOWN_CAST_CASE(uint, kUnsignedShort, ushort, saturate)
                    DOWN_CAST_CASE(uint, kInt, int, saturate)
                    SIMPLE_CAST_CASE(uint, kLong, Long)
                    SIMPLE_CAST_CASE(uint, kULong, ULong)
                    SIMPLE_CAST_CASE(uint, kUnsignedLong, ULong)

                    TO_FLOAT_CASE(uint)
                    TO_DOUBLE_CASE(uint)

                default:
                    log_error("ERROR: Invalid type given to "
                              "convert_explicit_value!!\n");
                    break;
            }
            break;

        case kUnsignedInt:
            uintPtr = (uint *)inRaw;
            switch (outType)
            {
                BOOL_CASE(uint)

                case kUInt:
                case kUnsignedInt:
                    memcpy(outRaw, inRaw, get_explicit_type_size(inType));
                    break;

                    DOWN_CAST_CASE(uint, kChar, char, saturate)
                    DOWN_CAST_CASE(uint, kUChar, uchar, saturate)
                    DOWN_CAST_CASE(uint, kUnsignedChar, uchar, saturate)
                    DOWN_CAST_CASE(uint, kShort, short, saturate)
                    DOWN_CAST_CASE(uint, kUShort, ushort, saturate)
                    DOWN_CAST_CASE(uint, kUnsignedShort, ushort, saturate)
                    DOWN_CAST_CASE(uint, kInt, int, saturate)
                    SIMPLE_CAST_CASE(uint, kLong, Long)
                    SIMPLE_CAST_CASE(uint, kULong, ULong)
                    SIMPLE_CAST_CASE(uint, kUnsignedLong, ULong)

                    TO_FLOAT_CASE(uint)
                    TO_DOUBLE_CASE(uint)

                default:
                    log_error("ERROR: Invalid type given to "
                              "convert_explicit_value!!\n");
                    break;
            }
            break;

        case kLong:
            LongPtr = (Long *)inRaw;
            switch (outType)
            {
                BOOL_CASE(Long)

                case kLong:
                    memcpy(outRaw, inRaw, get_explicit_type_size(inType));
                    break;

                    DOWN_CAST_CASE(Long, kChar, char, saturate)
                    DOWN_CAST_CASE(Long, kUChar, uchar, saturate)
                    DOWN_CAST_CASE(Long, kUnsignedChar, uchar, saturate)
                    DOWN_CAST_CASE(Long, kShort, short, saturate)
                    DOWN_CAST_CASE(Long, kUShort, ushort, saturate)
                    DOWN_CAST_CASE(Long, kUnsignedShort, ushort, saturate)
                    DOWN_CAST_CASE(Long, kInt, int, saturate)
                    DOWN_CAST_CASE(Long, kUInt, uint, saturate)
                    DOWN_CAST_CASE(Long, kUnsignedInt, uint, saturate)
                    DOWN_CAST_CASE(Long, kULong, ULong, saturate)
                    DOWN_CAST_CASE(Long, kUnsignedLong, ULong, saturate)

                    TO_FLOAT_CASE(Long)
                    TO_DOUBLE_CASE(Long)

                default:
                    log_error("ERROR: Invalid type given to "
                              "convert_explicit_value!!\n");
                    break;
            }
            break;

        case kULong:
            ULongPtr = (ULong *)inRaw;
            switch (outType)
            {
                BOOL_CASE(ULong)

                case kUnsignedLong:
                case kULong:
                    memcpy(outRaw, inRaw, get_explicit_type_size(inType));
                    break;

                    U_DOWN_CAST_CASE(ULong, kChar, char, saturate)
                    U_DOWN_CAST_CASE(ULong, kUChar, uchar, saturate)
                    U_DOWN_CAST_CASE(ULong, kUnsignedChar, uchar, saturate)
                    U_DOWN_CAST_CASE(ULong, kShort, short, saturate)
                    U_DOWN_CAST_CASE(ULong, kUShort, ushort, saturate)
                    U_DOWN_CAST_CASE(ULong, kUnsignedShort, ushort, saturate)
                    U_DOWN_CAST_CASE(ULong, kInt, int, saturate)
                    U_DOWN_CAST_CASE(ULong, kUInt, uint, saturate)
                    U_DOWN_CAST_CASE(ULong, kUnsignedInt, uint, saturate)
                    U_DOWN_CAST_CASE(ULong, kLong, Long, saturate)

                    TO_FLOAT_CASE(ULong)
                    TO_DOUBLE_CASE(ULong)

                default:
                    log_error("ERROR: Invalid type given to "
                              "convert_explicit_value!!\n");
                    break;
            }
            break;

        case kUnsignedLong:
            ULongPtr = (ULong *)inRaw;
            switch (outType)
            {
                BOOL_CASE(ULong)

                case kULong:
                case kUnsignedLong:
                    memcpy(outRaw, inRaw, get_explicit_type_size(inType));
                    break;

                    U_DOWN_CAST_CASE(ULong, kChar, char, saturate)
                    U_DOWN_CAST_CASE(ULong, kUChar, uchar, saturate)
                    U_DOWN_CAST_CASE(ULong, kUnsignedChar, uchar, saturate)
                    U_DOWN_CAST_CASE(ULong, kShort, short, saturate)
                    U_DOWN_CAST_CASE(ULong, kUShort, ushort, saturate)
                    U_DOWN_CAST_CASE(ULong, kUnsignedShort, ushort, saturate)
                    U_DOWN_CAST_CASE(ULong, kInt, int, saturate)
                    U_DOWN_CAST_CASE(ULong, kUInt, uint, saturate)
                    U_DOWN_CAST_CASE(ULong, kUnsignedInt, uint, saturate)
                    U_DOWN_CAST_CASE(ULong, kLong, Long, saturate)

                    TO_FLOAT_CASE(ULong)
                    TO_DOUBLE_CASE(ULong)

                default:
                    log_error("ERROR: Invalid type given to "
                              "convert_explicit_value!!\n");
                    break;
            }
            break;

        case kFloat:
            floatPtr = (float *)inRaw;
            switch (outType)
            {
                BOOL_CASE(float)

                FLOAT_ROUND_CASE(kChar, char, roundType, saturate)
                FLOAT_ROUND_CASE(kUChar, uchar, roundType, saturate)
                FLOAT_ROUND_CASE(kUnsignedChar, uchar, roundType, saturate)
                FLOAT_ROUND_CASE(kShort, short, roundType, saturate)
                FLOAT_ROUND_CASE(kUShort, ushort, roundType, saturate)
                FLOAT_ROUND_CASE(kUnsignedShort, ushort, roundType, saturate)
                FLOAT_ROUND_CASE(kInt, int, roundType, saturate)
                FLOAT_ROUND_CASE(kUInt, uint, roundType, saturate)
                FLOAT_ROUND_CASE(kUnsignedInt, uint, roundType, saturate)
                FLOAT_ROUND_CASE(kLong, Long, roundType, saturate)
                FLOAT_ROUND_CASE(kULong, ULong, roundType, saturate)
                FLOAT_ROUND_CASE(kUnsignedLong, ULong, roundType, saturate)

                case kFloat:
                    memcpy(outRaw, inRaw, get_explicit_type_size(inType));
                    break;

                    TO_DOUBLE_CASE(float);

                default:
                    log_error("ERROR: Invalid type given to "
                              "convert_explicit_value!!\n");
                    break;
            }
            break;

        case kDouble:
            doublePtr = (double *)inRaw;
            switch (outType)
            {
                BOOL_CASE(double)

                DOUBLE_ROUND_CASE(kChar, char, roundType, saturate)
                DOUBLE_ROUND_CASE(kUChar, uchar, roundType, saturate)
                DOUBLE_ROUND_CASE(kUnsignedChar, uchar, roundType, saturate)
                DOUBLE_ROUND_CASE(kShort, short, roundType, saturate)
                DOUBLE_ROUND_CASE(kUShort, ushort, roundType, saturate)
                DOUBLE_ROUND_CASE(kUnsignedShort, ushort, roundType, saturate)
                DOUBLE_ROUND_CASE(kInt, int, roundType, saturate)
                DOUBLE_ROUND_CASE(kUInt, uint, roundType, saturate)
                DOUBLE_ROUND_CASE(kUnsignedInt, uint, roundType, saturate)
                DOUBLE_ROUND_CASE(kLong, Long, roundType, saturate)
                DOUBLE_ROUND_CASE(kULong, ULong, roundType, saturate)
                DOUBLE_ROUND_CASE(kUnsignedLong, ULong, roundType, saturate)

                TO_FLOAT_CASE(double);

                case kDouble:
                    memcpy(outRaw, inRaw, get_explicit_type_size(inType));
                    break;

                default:
                    log_error("ERROR: Invalid type given to "
                              "convert_explicit_value!!\n");
                    break;
            }
            break;

        default:
            log_error(
                "ERROR: Invalid type given to convert_explicit_value!!\n");
            break;
    }
}

void generate_random_data(ExplicitType type, size_t count, MTdata d,
                          void *outData)
{
    bool *boolPtr;
    cl_char *charPtr;
    cl_uchar *ucharPtr;
    cl_short *shortPtr;
    cl_ushort *ushortPtr;
    cl_int *intPtr;
    cl_uint *uintPtr;
    cl_long *longPtr;
    cl_ulong *ulongPtr;
    cl_float *floatPtr;
    cl_double *doublePtr;
    cl_half *halfPtr;
    size_t i;
    cl_uint bits = genrand_int32(d);
    cl_uint bitsLeft = 32;

    switch (type)
    {
        case kBool:
            boolPtr = (bool *)outData;
            for (i = 0; i < count; i++)
            {
                if (0 == bitsLeft)
                {
                    bits = genrand_int32(d);
                    bitsLeft = 32;
                }
                boolPtr[i] = (bits & 1) ? true : false;
                bits >>= 1;
                bitsLeft -= 1;
            }
            break;

        case kChar:
            charPtr = (cl_char *)outData;
            for (i = 0; i < count; i++)
            {
                if (0 == bitsLeft)
                {
                    bits = genrand_int32(d);
                    bitsLeft = 32;
                }
                charPtr[i] = (cl_char)((cl_int)(bits & 255) - 127);
                bits >>= 8;
                bitsLeft -= 8;
            }
            break;

        case kUChar:
        case kUnsignedChar:
            ucharPtr = (cl_uchar *)outData;
            for (i = 0; i < count; i++)
            {
                if (0 == bitsLeft)
                {
                    bits = genrand_int32(d);
                    bitsLeft = 32;
                }
                ucharPtr[i] = (cl_uchar)(bits & 255);
                bits >>= 8;
                bitsLeft -= 8;
            }
            break;

        case kShort:
            shortPtr = (cl_short *)outData;
            for (i = 0; i < count; i++)
            {
                if (0 == bitsLeft)
                {
                    bits = genrand_int32(d);
                    bitsLeft = 32;
                }
                shortPtr[i] = (cl_short)((cl_int)(bits & 65535) - 32767);
                bits >>= 16;
                bitsLeft -= 16;
            }
            break;

        case kUShort:
        case kUnsignedShort:
            ushortPtr = (cl_ushort *)outData;
            for (i = 0; i < count; i++)
            {
                if (0 == bitsLeft)
                {
                    bits = genrand_int32(d);
                    bitsLeft = 32;
                }
                ushortPtr[i] = (cl_ushort)((cl_int)(bits & 65535));
                bits >>= 16;
                bitsLeft -= 16;
            }
            break;

        case kInt:
            intPtr = (cl_int *)outData;
            for (i = 0; i < count; i++)
            {
                intPtr[i] = (cl_int)genrand_int32(d);
            }
            break;

        case kUInt:
        case kUnsignedInt:
            uintPtr = (cl_uint *)outData;
            for (i = 0; i < count; i++)
            {
                uintPtr[i] = (unsigned int)genrand_int32(d);
            }
            break;

        case kLong:
            longPtr = (cl_long *)outData;
            for (i = 0; i < count; i++)
            {
                longPtr[i] = (cl_long)genrand_int32(d)
                    | ((cl_long)genrand_int32(d) << 32);
            }
            break;

        case kULong:
        case kUnsignedLong:
            ulongPtr = (cl_ulong *)outData;
            for (i = 0; i < count; i++)
            {
                ulongPtr[i] = (cl_ulong)genrand_int32(d)
                    | ((cl_ulong)genrand_int32(d) << 32);
            }
            break;

        case kFloat:
            floatPtr = (cl_float *)outData;
            for (i = 0; i < count; i++)
            {
                // [ -(double) 0x7fffffff, (double) 0x7fffffff ]
                double t = genrand_real1(d);
                floatPtr[i] = (float)((1.0 - t) * -(double)0x7fffffff
                                      + t * (double)0x7fffffff);
            }
            break;

        case kDouble:
            doublePtr = (cl_double *)outData;
            for (i = 0; i < count; i++)
            {
                cl_long u = (cl_long)genrand_int32(d)
                    | ((cl_long)genrand_int32(d) << 32);
                double t = (double)u;
                // scale [-2**63, 2**63] to [-2**31, 2**31]
                t *= MAKE_HEX_DOUBLE(0x1.0p-32, 0x1, -32);
                doublePtr[i] = t;
            }
            break;

        case kHalf:
            halfPtr = (ushort *)outData;
            for (i = 0; i < count; i++)
            {
                if (0 == bitsLeft)
                {
                    bits = genrand_int32(d);
                    bitsLeft = 32;
                }
                halfPtr[i] =
                    bits & 65535; /* Kindly generates random bits for us */
                bits >>= 16;
                bitsLeft -= 16;
            }
            break;

        default:
            log_error(
                "ERROR: Invalid type passed in to generate_random_data!\n");
            break;
    }
}

void *create_random_data(ExplicitType type, MTdata d, size_t count)
{
    void *data = malloc(get_explicit_type_size(type) * count);
    generate_random_data(type, count, d, data);
    return data;
}

cl_long read_upscale_signed(void *inRaw, ExplicitType inType)
{
    switch (inType)
    {
        case kChar: return (cl_long)(*((cl_char *)inRaw));
        case kUChar:
        case kUnsignedChar: return (cl_long)(*((cl_uchar *)inRaw));
        case kShort: return (cl_long)(*((cl_short *)inRaw));
        case kUShort:
        case kUnsignedShort: return (cl_long)(*((cl_ushort *)inRaw));
        case kInt: return (cl_long)(*((cl_int *)inRaw));
        case kUInt:
        case kUnsignedInt: return (cl_long)(*((cl_uint *)inRaw));
        case kLong: return (cl_long)(*((cl_long *)inRaw));
        case kULong:
        case kUnsignedLong: return (cl_long)(*((cl_ulong *)inRaw));
        default: return 0;
    }
}

cl_ulong read_upscale_unsigned(void *inRaw, ExplicitType inType)
{
    switch (inType)
    {
        case kChar: return (cl_ulong)(*((cl_char *)inRaw));
        case kUChar:
        case kUnsignedChar: return (cl_ulong)(*((cl_uchar *)inRaw));
        case kShort: return (cl_ulong)(*((cl_short *)inRaw));
        case kUShort:
        case kUnsignedShort: return (cl_ulong)(*((cl_ushort *)inRaw));
        case kInt: return (cl_ulong)(*((cl_int *)inRaw));
        case kUInt:
        case kUnsignedInt: return (cl_ulong)(*((cl_uint *)inRaw));
        case kLong: return (cl_ulong)(*((cl_long *)inRaw));
        case kULong:
        case kUnsignedLong: return (cl_ulong)(*((cl_ulong *)inRaw));
        default: return 0;
    }
}

float read_as_float(void *inRaw, ExplicitType inType)
{
    switch (inType)
    {
        case kChar: return (float)(*((cl_char *)inRaw));
        case kUChar:
        case kUnsignedChar: return (float)(*((cl_char *)inRaw));
        case kShort: return (float)(*((cl_short *)inRaw));
        case kUShort:
        case kUnsignedShort: return (float)(*((cl_ushort *)inRaw));
        case kInt: return (float)(*((cl_int *)inRaw));
        case kUInt:
        case kUnsignedInt: return (float)(*((cl_uint *)inRaw));
        case kLong: return (float)(*((cl_long *)inRaw));
        case kULong:
        case kUnsignedLong: return (float)(*((cl_ulong *)inRaw));
        case kFloat: return *((float *)inRaw);
        case kDouble: return (float)*((double *)inRaw);
        default: return 0;
    }
}

float get_random_float(float low, float high, MTdata d)
{
    float t = (float)((double)genrand_int32(d) / (double)0xFFFFFFFF);
    return (1.0f - t) * low + t * high;
}

double get_random_double(double low, double high, MTdata d)
{
    cl_ulong u =
        (cl_ulong)genrand_int32(d) | ((cl_ulong)genrand_int32(d) << 32);
    double t = (double)u * MAKE_HEX_DOUBLE(0x1.0p-64, 0x1, -64);
    return (1.0f - t) * low + t * high;
}

float any_float(MTdata d)
{
    union {
        float f;
        cl_uint u;
    } u;

    u.u = genrand_int32(d);
    return u.f;
}


double any_double(MTdata d)
{
    union {
        double f;
        cl_ulong u;
    } u;

    u.u = (cl_ulong)genrand_int32(d) | ((cl_ulong)genrand_int32(d) << 32);
    return u.f;
}

int random_in_range(int minV, int maxV, MTdata d)
{
    cl_ulong r = ((cl_ulong)genrand_int32(d)) * (maxV - minV + 1);
    return (cl_uint)(r >> 32) + minV;
}

size_t get_random_size_t(size_t low, size_t high, MTdata d)
{
    enum
    {
        N = sizeof(size_t) / sizeof(int)
    };

    union {
        int word[N];
        size_t size;
    } u;

    for (unsigned i = 0; i != N; ++i)
    {
        u.word[i] = genrand_int32(d);
    }

    assert(low <= high && "Invalid random number range specified");
    size_t range = high - low;

    return (range) ? low + ((u.size - low) % range) : low;
}