/*

* 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 Extension Library source file

*

*/

//File to implement functions to calculate trignomtric function

#include "Gfxtrignometric.h"

 /*-------------------------------------------------------------------*/

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

// TInt32 GfxMath::hgAbs32 (TInt32 a)

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

TInt32 GfxMath::hgAbs32 (TInt32 a)

{

	return (a >= 0) ? a : -a;

}

/*-------------------------------------------------------------------*//*!

 * \brief	Performs signed 32x32->64 multiplication, returns high 32 bits

 * \param	a	First 32-bit signed integer

 * \param	b	Second 32-bit signed integer

 * \return	((int64)(a)*b)>>32

 *//*-------------------------------------------------------------------*/

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

// TInt32 GfxMath::hgLsl64h_0_31 (

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

	TInt32 GfxMath::hgLsl64h_0_31 (

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

							   // const GfxMath::TGfxInt64	a,

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

							   const GfxMath::TGfxInt64	a,

							   TInt32			sh)

{

	return ((a.h << sh) | ((TUint32)(a.l) >> (32-sh)));

}

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

// GfxMath::TGfxInt64 GfxMath::hgSet64(TInt32 hh,TInt32 ll)

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

GfxMath::TGfxInt64 GfxMath::hgSet64(TInt32 hh,TInt32 ll)

{

	TGfxInt64 a;

	a.l=ll;

	a.h=hh;

	return a;

}

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

// GfxMath::TGfxInt64 GfxMath::hgMul64 (

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

	GfxMath::TGfxInt64 GfxMath::hgMul64 (

	TInt32 a,

	TInt32 b)

{

	TUint32 hh		= (TUint32)((a>>16)   *(b>>16));

	TUint32 lh		= (TUint32)((a&0xFFFF)*(b>>16));

	TUint32 hl		= (TUint32)((a>>16)   *(b&0xFFFF));

	TUint32 ll		= (TUint32)((a&0xFFFF)*(b&0xFFFF));

	TUint32 oldlo;

	hh += (TInt32)(lh)>>16;

	hh += (TInt32)(hl)>>16;

	oldlo	=  ll;

	ll		+= lh<<16;

	if (ll < oldlo)

		hh++;

	oldlo	=  ll;

	ll		+= hl<<16;

	if (ll < oldlo)

		hh++;

	return hgSet64((TInt32)hh,(TInt32)ll);

}

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

// GfxMath::TGfxInt64 GfxMath::hgAdd64 (

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

	GfxMath::TGfxInt64 GfxMath::hgAdd64 (

	const TGfxInt64 a,

	const TGfxInt64 b)

{

	TInt32 hi		= a.h+b.h;

	TInt32 lo		= a.l+b.l;

	hi += ((TUint32)(lo) < (TUint32)(a.l)) ? 1 : 0;

	return hgSet64(hi, lo);

}

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

// GfxMath::TGfxInt64 GfxMath::hgMadd64 (

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

	GfxMath::TGfxInt64 GfxMath::hgMadd64 (

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

	 // GfxMath::TGfxInt64 a,

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

	 GfxMath::TGfxInt64 a,

	TInt32 b,

	TInt32 c)

{

	return hgAdd64(a,hgMul64(b,c));

}

/*-------------------------------------------------------------------*//*!

 * \brief	Performs unsigned 32x32->64 multiplication, returns high

 *			32 bits

 * \param	a	First 32-bit  unsigned integer

 * \param	b	Second 32-bit unsigned integer

 * \return	((unsigned int64)(a)*b)>>32

 *//*-------------------------------------------------------------------*/

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

 // TUint32 GfxMath::hgMulu64h (

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

	 TUint32 GfxMath::hgMulu64h (

	TUint32 a,

	TUint32 b)

{

	TUint32 hh = (a>>16)	* (b>>16);

	TUint32 lh = (a&0xFFFF)* (b>>16);

	TUint32 hl = (a>>16)	* (b&0xFFFFu);

	TUint32 ll = (a&0xFFFF)* (b&0xFFFFu);

	TUint32 oldlo;

	hh += (lh>>16);

	hh += (hl>>16);

	oldlo = ll;

	ll += lh<<16;

	if (ll < oldlo)

		hh++;

	oldlo = ll;

	ll += hl<<16;

	if (ll < oldlo)

		hh++;

	return hh;

}

//-----------------------------------------------*/

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

 // GfxMath::TGfxInt64 GfxMath::hgMulu64 (

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

	 GfxMath::TGfxInt64 GfxMath::hgMulu64 (

	TUint32 a,

	TUint32 b)

{

	TUint32 hh = (a>>16)	* (b>>16);

	TUint32 lh = (a&0xFFFF)* (b>>16);

	TUint32 hl = (a>>16)	* (b&0xFFFFu);

	TUint32 ll = (a&0xFFFF)* (b&0xFFFFu);

	TUint32 oldlo;

	hh += (lh>>16);

	hh += (hl>>16);

	oldlo = ll;

	ll += lh<<16;

	if (ll < oldlo)

		hh++;

	oldlo = ll;

	ll += hl<<16;

	if (ll < oldlo)

		hh++;

	return hgSet64((TInt32)(hh),(TInt32)(ll));

}

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

// TInt GfxMath::svgiRCos( TInt32 _x )

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

TInt GfxMath::svgiRCos( TInt32 _x )

{

	TUint32 fpi = 0x6487ED51;

	TUint32 y;

	TUint32 x = hgAbs32(_x);

	y = x;

	if(y > fpi>>1)

		y = fpi-y;

	y <<= 1;

	/* Taylor series expansion around point x */

	/* NOTE: to adjust approximation accuracy vs speed, remove or add iterations in pairs */

	{

		TUint32 t;

		TGfxInt64 c  = hgMulu64(y,y<<1);

		TInt32	x2 = hgLsl64h_0_31(c,1);

 		t = hgMulu64h(x2,x2);

		c = hgMadd64(c, t,-(0x55555555>>1)-1);

		t = hgMulu64h(t,x2);

		c = hgMadd64(c, t, (0x5B05B05B>>4));

		t = hgMulu64h(t,x2);

		c = hgMadd64(c, t,-(0x68068068>>8)+1);

		t = hgMulu64h(t,x2);

		c = hgMadd64(c, t, (0x49F93EDD>>12)+1);

		t = hgMulu64h(t,x2);

		c = hgMadd64(c, t,-(0x47BB63BF>>17));

		{

			TInt32 r = c.h;

			r = (0x40000000 - r)>>1;

			if(x > (fpi>>1))

				r =-r;

			return r;

		}

	}

}

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

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

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

// TInt GfxMath::svgScalarSin( TInt r1 )

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

TInt GfxMath::svgScalarSin( TInt r1 )

{

	TInt32 foo;

	r1 -= 0x6487ED51>>14;

	foo = hgLsl64h_0_31(hgMul64(r1,0x517CC1B7),15);

	foo = hgMulu64h(foo,0x6487ED51);

	if( foo >= 0x6487ED51>>1 )

		foo -= 0x6487ED51>>0;

	return svgiRCos(foo<<1) >> 13;

}

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

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

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

// TInt GfxMath::svgScalarCos( TInt r1 )

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

TInt GfxMath::svgScalarCos( TInt r1 )

{

	TInt32 foo;

	foo = hgLsl64h_0_31(hgMul64(r1,0x517CC1B7),15);

	foo = hgMulu64h(foo,0x6487ED51);

	if( foo >= 0x6487ED51>>1 )

		foo -= 0x6487ED51>>0;

	return svgiRCos(foo<<1) >> 13;

}

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

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

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

// TInt GfxMath::svgScalarTan( TInt r1 )

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

TInt GfxMath::svgScalarTan( TInt r1 )

{

	TInt lSin = svgScalarSin(r1);

		if(!lSin)

			return 0xffffffff; //highest value possible to indicate error

	TInt lCos = svgScalarCos(r1);

		if ( !lCos  )

		{

		return 0xffffffff;

		}

	return (((lSin << 15) / lCos)<<1);

}