/*
* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Graphics Math Utility functions
*
*/

#include "Gfxmath.h"


/*-------------------------------------------------------------------*//*!
 * \brief   Counts number of leading zeroes in an integer
 * \param   value   Integer value
 * \return  Number of leading zeroes [0,32]
 * \note    Example outputs: clz(0)=32, clz(1)=31, clz(-1)=0
 * \todo    We want to generate clz instruction for ARM if supported by the CPU
 *//*-------------------------------------------------------------------*/

static int svgClz32(unsigned int value)
    {
    int c = 0;

    if (value<(1u<<( 16 )))
        c+=( 16 );
    else
        value >>= ( 16 );;
    if (value<(1u<<( 8 )))
        c+=( 8 );
    else
        value >>= ( 8 );;
    if (value<(1u<<( 4 )))
        c+=( 4 );
    else
        value >>= ( 4 );;
    if (value<(1u<<( 2 )))
        c+=( 2 );
    else
        value >>= ( 2 );;
    c += 2 >> value;

    return c;

    }

/*-------------------------------------------------------------------*//*!
 * \brief   Returns absolute value of an integer
 * \param   a   32-bit input value
 * \return  abs(a)
 * \todo    On many platforms it might be best to use native abs() ?
 *//*-------------------------------------------------------------------*/
static int svgAbs32 (int a)
    {
    return (a >= 0) ? a : -a;
    }

static int svgGTEFloat(int lhs, int rhs)
    {
    int cmp;
    if ((lhs & rhs) >> 31)
        {
        cmp = (int)lhs <= (int)rhs;
        }
    else
        {
        cmp = (int)lhs >= (int)rhs;
        }
    return cmp;
    }

static int svgLTEFloat(int lhs, int rhs)
    {
    /* Compare signed, if both are negative, we need to invert the result */
    int cmp;
    if ((lhs & rhs) >> 31)
        {
        cmp = (int)lhs >= (int)rhs;
        }
    else
        {
        cmp = (int)lhs <= (int)rhs;
        }
    return cmp;
    }

/**
 * \brief   Clamping version of the fixed -> float conversion routine. That is, will not
 *          create incorrect results on values > ~32768.0 or < -32768.0
 *
 * \param f Input floating-point
 * \return  Fixed-point number within 16.16 fixed-point range.
 */
 int svgScalarFromFloat(float f)
    {
    int a;
    int sign;
    int exponent;

    int r;

    if (svgGTEFloat((*(int*)&f ), 0x47000000) )
        {
        return 0x7fffffff;
        }
    else
        if (svgLTEFloat((*(int*)&f ), 0xc7000000) )
            {
            return 0x80000000;
            }
        else
            {
            a = (*(int*)&f );
            sign = a >> 31;
            exponent = (127 + 15) - ((a >> 23) & 0xff);

            r = (int)((((int)(a) << 8) | (1U << 31)) >> exponent);
            r &= ((exponent - 32) >> 31);

            r = (r ^ sign) - sign;

            return r;
            }
    }

/*********************************************************************//*!
 * \internal
 *
 * \brief   Converts a 16.16 fixed point value into a floating point
 *          value
 * \param   x Fixed point value
 * \returns Corresponding floating point value
 * \note    This is essentially exactly the same routine as nglIntToFloat,
 *          except that the exponent bias value is 16 smaller (thus
 *          dividing the float by 65536). If we run out of space and
 *          want to squeeze out a few extra bytes, we could write a
 *          common routine where the scale factor is passed in as
 *          a parameter.
 *
 ************************************************************************/

float svgFixedToFloat(int x)
    {
    unsigned int d = (unsigned int)(x) & 0x80000000u; /* get copy of sign */
    int exponent;

    if (!x) /* special case handling for 0 */
        return (float)(0);

    x = svgAbs32(x); /* get rid of sign (the code works only for unsigned values -> we add the sign later back)  */

    /*exponent = nglGetHighestSetBit((unsigned int)(x))-23;*//* get exponent and divide value */
    exponent = 31 - svgClz32((unsigned int)(x)) - 23;

    if (exponent >= 0) /* "signed shift right" (we shift the mantissa to the proper place) */
        x>>=exponent;
    else
        x<<=(-exponent); /*lint !e504 *//* yes, it is an unusual shift.. */

    exponent += 127+23-16; /* convert exponent into biased form (divide by 65536 simultaneously!)  */
    exponent <<=23; /* shift exponent to proper place           */
    d |= (unsigned int)(exponent); /* combine sign with exponent               */
    x &= ((1<<23)-1); /* mask the mantissa                        */
    d |= (unsigned int)(x); /* combine sign and exponent with mantissa  */

    return *(float*)&d; /* done */
    }

/*-------------------------------------------------------------------*//*!
 * \brief   32x32->64-bit signed multiplication
 * \param   a   32-bit signed integer
 * \param   b   32-bit signed integer
 * \return  64-bit signed result of the multiplication
 *//*-------------------------------------------------------------------*/

static svgInt64 svgMul64(int a, int b)
    {
    return (svgInt64)(a) * (int)(b);
    }
/*=======================================================================*/
/*=======================================================================*/

int svgScalarMul(int r1, int r2)
    {

    svgInt64 a = svgMul64(r1, r2);
    int l = (int)(a);
    int h = (int)((svgUint64)(a)>>32);
    int r = (h << 16) | (((unsigned int)l) >> 16); /* r = 32 middle bits of the 64 bit result */
    int hs = h >> 31; /* hs is either 0 or 0xffffffff */
    /* test if there is data in the upper 17 bits of h */
    if ( (h >> 15) != hs)
        r = (~hs) ^ 0x80000000; /* saturate (~hs to avoid a big constant on ARM) */

    return r;
    }

/*=======================================================================*/
/*=======================================================================*/

int svgScalarDiv(int x, int y)
    {
    unsigned int ax = x < 0 ? -x : x;
    unsigned int ay = y < 0 ? -y : y;
    unsigned int axh = ax >> 14;
    unsigned int axl = ax << 18;
    int q = 0, i;

    if ((axh >> 1) >= ay)
        { /* saturate when overflows */
        if ( (x < 0) ^ (y < 0))
            q = 0x80000000;
        else
            q = 0x7fffffff;
        }
    else
        {
        for (i = 30; i>=0; i--)
            {
            if (axh >= ay)
                {
                axh -= ay;
                q += 1<<i;
                }
            /* lsl64 #1 */
            axh <<= 1;
            axh |= axl >> 31; /* add carry */
            axl <<= 1;
            }
        if ( (x < 0) ^ (y < 0))
            q = -q;
        }

    return q;
    }