/********************************************************************

 *                                                                  *

 * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE.   *

 *                                                                  *

 * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *

 * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *

 * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *

 *                                                                  *

 * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002    *

 * BY THE Xiph.Org FOUNDATION http://www.xiph.org/                  *

 *                                                                  *

 ********************************************************************

 function: miscellaneous math and prototypes

 ********************************************************************/

#ifndef _V_RANDOM_H_

#define _V_RANDOM_H_

#include "ivorbiscodec.h"

#include "os.h"

#include "asm_arm.h"

#include <stdlib.h> /* for abs() */

#ifndef _V_WIDE_MATH

#define _V_WIDE_MATH

#ifndef  _LOW_ACCURACY_

/* 64 bit multiply */

#if !(defined WIN32 && defined WINCE)

#include <sys/types.h>

#endif

#if BYTE_ORDER==LITTLE_ENDIAN

union magic {

  struct {

    ogg_int32_t lo;

    ogg_int32_t hi;

  } halves;

  ogg_int64_t whole;

};

#endif 

#if BYTE_ORDER==BIG_ENDIAN

union magic {

  struct {

    ogg_int32_t hi;

    ogg_int32_t lo;

  } halves;

  ogg_int64_t whole;

};

#endif

STIN ogg_int32_t MULT32(ogg_int32_t x, ogg_int32_t y) {

  union magic magic;

  magic.whole = (ogg_int64_t)x * y;

  return magic.halves.hi;

}

STIN ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) {

  return MULT32(x,y)<<1;

}

STIN ogg_int32_t MULT31_SHIFT15(ogg_int32_t x, ogg_int32_t y) {

  union magic magic;

  magic.whole  = (ogg_int64_t)x * y;

  return ((ogg_uint32_t)(magic.halves.lo)>>15) | ((magic.halves.hi)<<17);

}

#else

/* 32 bit multiply, more portable but less accurate */

/*

 * Note: Precision is biased towards the first argument therefore ordering

 * is important.  Shift values were chosen for the best sound quality after

 * many listening tests.

 */

/*

 * For MULT32 and MULT31: The second argument is always a lookup table

 * value already preshifted from 31 to 8 bits.  We therefore take the 

 * opportunity to save on text space and use unsigned char for those

 * tables in this case.

 */

STIN ogg_int32_t MULT32(ogg_int32_t x, ogg_int32_t y) {

  return (x >> 9) * y;  /* y preshifted >>23 */

}

STIN ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) {

  return (x >> 8) * y;  /* y preshifted >>23 */

}

STIN ogg_int32_t MULT31_SHIFT15(ogg_int32_t x, ogg_int32_t y) {

  return (x >> 6) * y;  /* y preshifted >>9 */

}

#endif

/*

 * This should be used as a memory barrier, forcing all cached values in

 * registers to wr writen back to memory.  Might or might not be beneficial

 * depending on the architecture and compiler.

 */

#define MB()

/*

 * The XPROD functions are meant to optimize the cross products found all

 * over the place in mdct.c by forcing memory operation ordering to avoid

 * unnecessary register reloads as soon as memory is being written to.

 * However this is only beneficial on CPUs with a sane number of general

 * purpose registers which exclude the Intel x86.  On Intel, better let the

 * compiler actually reload registers directly from original memory by using

 * macros.

 */

#ifdef __i386__

#define XPROD32(_a, _b, _t, _v, _x, _y)		\

  { *(_x)=MULT32(_a,_t)+MULT32(_b,_v);		\

    *(_y)=MULT32(_b,_t)-MULT32(_a,_v); }

#define XPROD31(_a, _b, _t, _v, _x, _y)		\

  { *(_x)=MULT31(_a,_t)+MULT31(_b,_v);		\

    *(_y)=MULT31(_b,_t)-MULT31(_a,_v); }

#define XNPROD31(_a, _b, _t, _v, _x, _y)	\

  { *(_x)=MULT31(_a,_t)-MULT31(_b,_v);		\

    *(_y)=MULT31(_b,_t)+MULT31(_a,_v); }

#else

STIN void XPROD32(ogg_int32_t  a, ogg_int32_t  b,

			   ogg_int32_t  t, ogg_int32_t  v,

			   ogg_int32_t *x, ogg_int32_t *y)

{

  *x = MULT32(a, t) + MULT32(b, v);

  *y = MULT32(b, t) - MULT32(a, v);

}

STIN void XPROD31(ogg_int32_t  a, ogg_int32_t  b,

			   ogg_int32_t  t, ogg_int32_t  v,

			   ogg_int32_t *x, ogg_int32_t *y)

{

  *x = MULT31(a, t) + MULT31(b, v);

  *y = MULT31(b, t) - MULT31(a, v);

}

STIN void XNPROD31(ogg_int32_t  a, ogg_int32_t  b,

			    ogg_int32_t  t, ogg_int32_t  v,

			    ogg_int32_t *x, ogg_int32_t *y)

{

  *x = MULT31(a, t) - MULT31(b, v);

  *y = MULT31(b, t) + MULT31(a, v);

}

#endif

#endif

#ifndef _V_CLIP_MATH

#define _V_CLIP_MATH

STIN ogg_int32_t CLIP_TO_15(ogg_int32_t x) {

  int ret=x;

  ret-= ((x<=32767)-1)&(x-32767);

  ret-= ((x>=-32768)-1)&(x+32768);

  return(ret);

}

#endif

STIN ogg_int32_t VFLOAT_MULT(ogg_int32_t a,ogg_int32_t ap,

				      ogg_int32_t b,ogg_int32_t bp,

				      ogg_int32_t *p){

  if(a && b){

#ifndef _LOW_ACCURACY_

    *p=ap+bp+32;

    return MULT32(a,b);

#else

    *p=ap+bp+31;

    return (a>>15)*(b>>16); 

#endif

  }else

    return 0;

}

int _ilog(unsigned int);

STIN ogg_int32_t VFLOAT_MULTI(ogg_int32_t a,ogg_int32_t ap,

				      ogg_int32_t i,

				      ogg_int32_t *p){

  int ip=_ilog(abs(i))-31;

  return VFLOAT_MULT(a,ap,i<<-ip,ip,p);

}

STIN ogg_int32_t VFLOAT_ADD(ogg_int32_t a,ogg_int32_t ap,

				      ogg_int32_t b,ogg_int32_t bp,

				      ogg_int32_t *p){

  if(!a){

    *p=bp;

    return b;

  }else if(!b){

    *p=ap;

    return a;

  }

  /* yes, this can leak a bit. */

  if(ap>bp){

    int shift=ap-bp+1;

    *p=ap+1;

    a>>=1;

    if(shift<32){

      b=(b+(1<<(shift-1)))>>shift;

    }else{

      b=0;

    }

  }else{

    int shift=bp-ap+1;

    *p=bp+1;

    b>>=1;

    if(shift<32){

      a=(a+(1<<(shift-1)))>>shift;

    }else{

      a=0;

    }

  }

  a+=b;

  if((a&0xc0000000)==0xc0000000 || 

     (a&0xc0000000)==0){

    a<<=1;

    (*p)--;

  }

  return(a);

}

#endif