/*==============================================================================
Copyright(c) 2017 Intel Corporation

Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files(the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and / or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
============================================================================*/

#ifndef __GFXMACRO_H__
#define __GFXMACRO_H__

#include <limits.h>
#include <string.h> // for memcpy
#include <stdint.h>

// ### __GFXMACRO_ASSERT ######################################################
// Since an "always-callable" GFX_ASSERT/etc. is no longer really in-place,
// this file will define its own assert statement...
#if DBG
    #define __GFXMACRO_ASSERT(Expression)   \
    {                                       \
        if(!(Expression))                   \
        {                                   \
            __debugbreak();                 \
        }                                   \
    } // __GFXMACRO_ASSERT ##################
#else // Release Build
    #define __GFXMACRO_ASSERT(Expression)
#endif


//------------------------------------------------------------------------
// Useful constants.

#define GFX_ZERO                (0.0f)
#define GFX_HALF                (0.5f)
#define GFX_PI                  ((float) 3.14159265358979323846)
#define GFX_SQR_ROOT_OF_TWO     ((float) 1.41421356237309504880)
#define GFX_E                   ((float) 2.7182818284590452354)

//------------------------------------------------------------------------

// !!! Many of these are macros (instead of functions) so 64-bit friendly (even on 32-bit builds)!!!

#define GFX_IS_ALIGNED(A, B)       (((B) > 0) && (((A) % (B)) == 0))
#define GFX_ALIGN(x, a)          (((x) + ((a) - 1)) - (((x) + ((a) - 1)) & ((a) - 1))) // Alt implementation with bitwise not (~) has issue with uint32 align used with 64-bit value, since ~'ed value will remain 32-bit.
#define GFX_ALIGN_FLOOR(x, a)    ((x) - ((x) & ((a) - 1)))

#define GFX_ALIGN_NP2(x, a)      (((a) > 0) ? ((x) + (((a) - 1) - (((x) + ((a) - 1)) % (a)))) : (x))
#define GFX_ALIGN_FLOOR_NP2(x, a) (((a) > 0) ? ((x) - ((x) % (a))) : (x))

#define GFX_MASK(lo,hi)          ((1UL << (hi)) |    \
                                 ((1UL << (hi)) -    \
                                  (1UL << (lo))))

#define GFX_MASK_LARGE(lo,hi)    (((uint64_t)1 << (hi)) |  \
                                 (((uint64_t)1 << (hi)) -  \
                                  ((uint64_t)1 << (lo))))

#define GFX_IS_POWER_OF_2(a)     (((a) > 0) && !((a) & ((a) - 1)))

#define GFX_SWAP_VAR(a,b,t)      (t=a, a=b, b=t)
#define GFX_SWAP_VAR3(a,b,c,t)   (t=a, a=b, b=c, c=t)

#define GFX_UF_ROUND(a)          ((uint32_t) ((a) + 0.5F))
#define GFX_F_ROUND(a)           ((int32_t) ((a) + ((a) < 0 ? -0.5F : 0.5F)))
#define GFX_ABS(a)               (((a) < 0) ? -(a) : (a))

#define GFX_MIN(a,b)             (((a) < (b)) ? (a) : (b))
#define GFX_MAX(a,b)             (((a) > (b)) ? (a) : (b))

#define GFX_MIN3(a,b,c)          (((a) < (b)) ?  GFX_MIN((a), (c)) : GFX_MIN((b), (c)))
#define GFX_MAX3(a,b,c)          (((a) > (b)) ?  GFX_MAX((a), (c)) : GFX_MAX((b), (c)))

#define GFX_CEIL_DIV(a,b)        (((b) > 0) ? (((a) + ((b) - 1)) / (b)) : (a))

#define GFX_SQ(a)                ((a) * (a))

#define GFX_CLAMP_MIN_MAX(a,min,max)   ((a) < (min) ? (min) : GFX_MIN ((a), (max)))

#define GFX_KB(k)                ((k) * 1024)
#define GFX_MB(m)                ((m) * 1024 * 1024)

//------------ Macros for setting and removing bits.

#define GFX_BIT(n)               (1UL << (n))
#define GFX_BIT_ON(a,bit)        ((a) |= (bit))
#define GFX_BIT_OFF(a,bit)       ((a) &= ~(bit))
#define GFX_IS_BIT_SET(a,bit)    ((a) & (bit))

//*****************************************************************************
// MACRO: GFX_BIT_RANGE
// PURPOSE: Calculates the number of bits between the startbit and the endbit
// and count is inclusive of both bits. The bits are 0 based.
//*****************************************************************************
#define GFX_BIT_RANGE(endbit, startbit)     ((endbit)-(startbit)+1)

//------------ Macros for dealing with void pointers

#define GFX_VOID_PTR_INC(p,n)   ((void *) ((char *)(p) + (n)))
#define GFX_VOID_PTR_DEC(p,n)   ((void *) ((char *)(p) - (n)))

// While the difference of two pointers on a 64-bit machine can exceed
// 32-bits, it is mostly limited to 32-bits for the graphics driver. In
// order to avoid compilation warnings arising from assigning a 64-bit
// quantity to a 32-bit lvalue, we have two separate macros for obtaining
// pointer difference of two pointers.

#define GFX_VOID_PTR_DIFF(a,b)       (int32_t) ((char *) (a) - (char *) (b))
#define GFX_VOID_PTR_DIFF_LARGE(a,b)        ((char *) (a) - (char *) (b))

//------------ Bytes to page conversion

#define GFX_BYTES_TO_PAGES(b)   (((b) + PAGE_SIZE - 1) / PAGE_SIZE)
#define GFX_PAGES_TO_BYTES(p)   ((p) * PAGE_SIZE)

#define GFX_MEMSET(p,d,s)       (memset(p, d, s))

#if DBG
    #define GFX_ULONG_CAST(x)   \
    (                           \
        ((x) <= 0xffffffff) ?   \
            1 : __debugbreak(), \
        (uint32_t)(x)              \
    )
#else // Release Build
    #define GFX_ULONG_CAST(x) ((uint32_t)(x))
#endif

// Since hardware addresses are still 32 bits, we need a safe way
// to convert 64 bit pointers into 32 bit hardware addresses.
// ASSERT that the upper 32 bits are 0 before truncating address.
#define GFX_VOID_PTR_TO_ULONG(ptr)  ((uint32_t)(ptr))


//------------------------------------------------------------------------
// FAST FLOAT-TO_LONG CONVERSION
//
// We can convert floats to integers quickly by adding a floating-point
// constant to an IEEE float so that the integer value of the IEEE float is
// found in the least significant bits of the sum. We add 2^23 + 2^22, and
// thus the number is represented in IEEE single-precision as
// 2^23*(1.1xxxxxxx), where the first 1 is the implied one, the second is 1 .
//
// This technique has several limitations:
//   1. It only works on values in the range [0,2^22-1].
//   2. It is subject to the processor rounding mode, which we assume to be
//      "round to nearest (even)".  In this rounding mode, the conversion
//      yields round(x), not floor(x) as called for in C.
//
// It can be made to work on negative values with a little fixed point
// trickery by:
//      result = ((LONG) (result ^ 0x00800000) << 8) >> 8,
//
// However, when the result is masked to a byte or a short and directly
// assigned to the right type, no sign extension is required.
//
// The macros for -ve numbers since we use a constant of "1100" in binary
// representation. The msb 1 is force it to be the implicit bit. The next
// 1 is used for -ve numbers which will force other bits to be FFF..
//
// which flips and then smears the sign bit into the rest of the number.  The
// intermediate values must be signed, so we do an arithmetic (fill with sign
// bit) instead of logical shift.
//
// We approximate the floor operation by subtracting off 0.5 before doing the
// round.  This would work perfectly except that the processor breaks ties in
// rounding be selecting the even value.  Thus, we compute floor(1.0) as
// round(0.5) = 0!  Not good -- the caller must be careful to use
// __GL_FLOAT_TO_LONG_TRUNC only in cases where he can live with this
// behavior.

#define GFX_FLOAT_TO_LONG_ROUND(ux,x,mask)      \
{                                               \
    float fx;                                   \
                                                \
    fx = x;                                     \
    fx += 0x00C00000;                           \
    ux = mask & *(uint32_t *) &fx;					\
}

#define GFX_FLOAT_TO_LONG_TRUNC(ux,x,mask)      \
{                                               \
    float fx;                                   \
                                                \
    fx = x - GFX_HALF;                          \
    fx += 0x00C00000;                           \
    ux = mask & *(uint32_t *) &fx;					\
}

// Note: Double has 1 sign bit, 11 exponent and 52 mantissa bits.
// We need to add the following constant for fast conversion
//
//  fx += (__LONG64) 0x18000000000000;
//
// This is done in a portable/decipherable manner through
// multiplications which are collapsed by the compiler at compile time.

#define GFX_DOUBLE_TO_LONG_ROUND(ux,x,mask)     		  \
{                                               		  \
    double fx;                                		      \
                                                		  \
    fx = x;                                     		  \
	fx += 24.0 * 1024.0 * 1024.0 * 1024.0 * 1024.0 * 256; \
    ux = mask & *(uint32_t *) &fx;                		      \
}

#define GFX_DOUBLE_TO_LONG_TRUNC(ux,x,mask)     		  \
{                                               		  \
    double fx;                                   		  \
                                                		  \
    fx = x - GFX_HALF;                             		  \
	fx += 24.0 * 1024.0 * 1024.0 * 1024.0 * 1024.0 * 256; \
    ux = mask & *(uint32_t *) &fx;							  \
}

#if __DEFINE_PROTO || defined __GFX_MACRO_C__
    extern uint32_t GFX_LOG2 (uint32_t a);
    extern uint32_t GFX_REAL_TO_UBYTE (float a);
    extern int64_t GFX_POW2_SIZE (int64_t x);
    extern uint32_t GFX_2_TO_POWER_OF (uint32_t w);
    extern uint32_t GFX_MEMCPY_S(void *d, int dn, const void *s, int n);
    extern void* GFX_MEMCPY_S_INC(void *d, int dn, const void *s, int n);
#endif // __DEFINE_PROTO

#ifndef __S_INLINE
    #define __S_INLINE __inline
#endif

#if __DEFINE_MACRO || defined __GFX_MACRO_C__
//------------------------------------------------------------------------

__S_INLINE uint32_t GFX_LOG2 (uint32_t a)
{
	long	i = 1;

	while ((a >> i) > 0) {
		i++;
	}

	return (i - 1);
}

// Round-up to next power-of-2
__S_INLINE int64_t GFX_POW2_SIZE (int64_t x)
{	                            //-- Signed instead of unsigned since 64-bit is large enough that we don't need unsigned's range extension.
    int64_t Pow2Size;

    /* Algorithm:
        If there are no bits lit beneath the highest bit lit (HBL), the value
        is already a power-of-2 and needs no further rounding but if there are
        additional bits lit beneath the highest, the next higher power-of-2 is
        (1 << (HBL + 1)). To determine if there are bits lit beneath the HBL,
        we will subtract 1 from the given value before scanning for the HBL,
        and only if there are no lower bits lit will the subtraction reduce the
        HBL but in both cases, (1 << (HBL + 1)) will then produce the
        appropriately rounded-up (or not) power-of-2.
    */

    if(x > 1) // <-- Since we bit-scan for (x - 1) and can't bit-scan zero.
    {
        #define MSB (sizeof(x) * CHAR_BIT - 1)

        uint32_t HighBit;

        { // HighBit = HighestBitLit(x - 1)...
            #if defined(__GNUC__) || defined(__clang__)
            {
                HighBit = MSB - __builtin_clzll(x - 1);
            }
            #else // Windows
            {
                #ifdef __CT__
                {
                    _BitScanReverse64((DWORD *)&HighBit, x - 1);
                }
                #else // Break into separate Upper/Lower scans...
                {
                    #define UDW_1 ((int64_t) _UI32_MAX + 1) // <-- UpperDW Value of 1 (i.e. 0x00000001`00000000).

                    if(x < UDW_1)
                    {
                        _BitScanReverse((DWORD *)&HighBit, GFX_ULONG_CAST(x - 1));
                    }
                    else if(x > UDW_1)
                    {
                        _BitScanReverse((DWORD *)&HighBit, GFX_ULONG_CAST((x - 1) >> 32));
                        HighBit += 32;
                    }
                    else
                    {
                        HighBit = 31;
                    }

                    #undef UDW_1
                }
                #endif
            }
            #endif
        }

        if(HighBit < (MSB - 1)) // <-- -1 since operating on signed type.
        {
            Pow2Size = (int64_t) 1 << (HighBit + 1);
        }
        else
        {
            __GFXMACRO_ASSERT(0); // Overflow!
            Pow2Size = 0;
        }

        #undef MSB
    }
    else
    {
        Pow2Size = 1;
    }

    return(Pow2Size);
} // GFX_POW2_SIZE

// Find 2 to the power of w
__S_INLINE uint32_t GFX_2_TO_POWER_OF (uint32_t w)
{
    __GFXMACRO_ASSERT(w < (sizeof(w) * CHAR_BIT)); // Assert no overflow.

    return(1UL << w);
}

__S_INLINE uint32_t GFX_REAL_TO_UBYTE (float a)
{
    uint32_t x;
    GFX_FLOAT_TO_LONG_ROUND(x, a, 0xFF);
    return x;
}

__S_INLINE uint32_t GFX_MEMCPY_S(void *d, int dn, const void *s, int n)
{
    uint32_t Error;

    // Check for the size, overlapping, etc.
    // Calling code responsibility to avoid overlap regions
    __GFXMACRO_ASSERT(n >= 0);
    __GFXMACRO_ASSERT(
        (((char*) d >= (char*) s) && ((ULONG_PTR)((char*) d - (char*) s) >= (ULONG_PTR) n) ) ||
        (((char*) s >= (char*) d) && ((ULONG_PTR)((char*) s - (char*) d) >= (ULONG_PTR) n) ));

    #ifndef _WIN32
        Error = 0;
        if(n <= dn)
        {
            memcpy(d, s, n);
        }
        else
        {
            Error = !Error;
        }
    #else
        Error = (uint32_t) memcpy_s(d, dn, s, n);
    #endif

    __GFXMACRO_ASSERT(!Error);
    return(Error);
}

__S_INLINE void* GFX_MEMCPY_S_INC(void *d, int dn, const void *s, int n)
{
    GFX_MEMCPY_S(d, dn, s, n);
    return GFX_VOID_PTR_INC(d, n);
}

__S_INLINE uint32_t GFX_GET_NONZERO_BIT_COUNT(uint32_t bitMask)
{
    uint32_t bitCount = 0;
    while(bitMask)
    {
        bitCount += bitMask & 0x1;
        bitMask >>= 1;
    }

    return bitCount;
}

#endif

//#include <intrin.h>

// __readmsr should not be called for vGT cases, use __try __except to handle the
// exception and assign it with hard coded values
// isVGT flag will be set if it's being called from vGT.


#define GFX_READ_MSR(pHwDevExt, value, reg, retParam)        \
    if(!gfx_read_msr((pHwDevExt), &(value), (reg))) return retParam;
#define GFX_WRITE_MSR(pHwDevExt, reg, value, retParam)\
    if(!gfx_write_msr((pHwDevExt), (value), (reg))) return retParam;

#define GFX_READ_MSR_GOTO_LABEL_ON_ERROR(pHwDevExt, value, reg, label)        \
    if(!gfx_read_msr((pHwDevExt), &(value), (reg))) goto label;

#define GFX_WRITE_MSR_GOTO_LABEL_ON_ERROR(pHwDevExt, reg, value,  label)\
    if(!gfx_write_msr((pHwDevExt), (value), (reg))) goto label;
#endif // __GFXMACRO_H__