apps/codecs/libtremor/misc.h

   1 /********************************************************************
   2  *                                                                  *
   3  * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE.   *
   4  *                                                                  *
   5  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
   6  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
   7  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
   8  *                                                                  *
   9  * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002    *
  10  * BY THE Xiph.Org FOUNDATION http://www.xiph.org/                  *
  11  *                                                                  *
  12  ********************************************************************
  13
  14  function: miscellaneous math and prototypes
  15
  16  ********************************************************************/
  17
  18 #include "config-tremor.h"
  19
  20 #ifndef _V_RANDOM_H_
  21 #define _V_RANDOM_H_
  22 #include "ivorbiscodec.h"
  23 #include "os_types.h"
  24
  25 #include "asm_arm.h"
  26 #include "asm_mcf5249.h"
  27
  28
  29 /* Some prototypes that were not defined elsewhere */
  30 void *_vorbis_block_alloc(vorbis_block *vb,long bytes);
  31 void _vorbis_block_ripcord(vorbis_block *vb);
  32 extern int _ilog(unsigned int v);
  33
  34 #ifndef _V_WIDE_MATH
  35 #define _V_WIDE_MATH
  36
  37 #ifndef  _LOW_ACCURACY_
  38 /* 64 bit multiply */
  39 /* #include <sys/types.h> */
  40
  41 #if BYTE_ORDER==LITTLE_ENDIAN
  42 union magic {
  43   struct {
  44     ogg_int32_t lo;
  45     ogg_int32_t hi;
  46   } halves;
  47   ogg_int64_t whole;
  48 };
  49 #elif BYTE_ORDER==BIG_ENDIAN
  50 union magic {
  51   struct {
  52     ogg_int32_t hi;
  53     ogg_int32_t lo;
  54   } halves;
  55   ogg_int64_t whole;
  56 };
  57 #endif
  58
  59 static inline ogg_int32_t MULT32(ogg_int32_t x, ogg_int32_t y) {
  60   union magic magic;
  61   magic.whole = (ogg_int64_t)x * y;
  62   return magic.halves.hi;
  63 }
  64 static inline ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) {
  65   return MULT32(x,y)<<1;
  66 }
  67
  68 static inline ogg_int32_t MULT31_SHIFT15(ogg_int32_t x, ogg_int32_t y) {
  69   union magic magic;
  70   magic.whole  = (ogg_int64_t)x * y;
  71   return ((ogg_uint32_t)(magic.halves.lo)>>15) | ((magic.halves.hi)<<17);
  72 }
  73
  74 #else
  75 /* 32 bit multiply, more portable but less accurate */
  76
  77 /*
  78  * Note: Precision is biased towards the first argument therefore ordering
  79  * is important.  Shift values were chosen for the best sound quality after
  80  * many listening tests.
  81  */
  82
  83 /*
  84  * For MULT32 and MULT31: The second argument is always a lookup table
  85  * value already preshifted from 31 to 8 bits.  We therefore take the
  86  * opportunity to save on text space and use unsigned char for those
  87  * tables in this case.
  88  */
  89
  90 static inline ogg_int32_t MULT32(ogg_int32_t x, ogg_int32_t y) {
  91   return (x >> 9) * y;  /* y preshifted >>23 */
  92 }
  93
  94 static inline ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) {
  95   return (x >> 8) * y;  /* y preshifted >>23 */
  96 }
  97
  98 static inline ogg_int32_t MULT31_SHIFT15(ogg_int32_t x, ogg_int32_t y) {
  99   return (x >> 6) * y;  /* y preshifted >>9 */
 100 }
 101 #endif
 102
 103 /*
 104  * This should be used as a memory barrier, forcing all cached values in
 105  * registers to wr writen back to memory.  Might or might not be beneficial
 106  * depending on the architecture and compiler.
 107  */
 108 #define MB()
 109
 110 /*
 111  * The XPROD functions are meant to optimize the cross products found all
 112  * over the place in mdct.c by forcing memory operation ordering to avoid
 113  * unnecessary register reloads as soon as memory is being written to.
 114  * However this is only beneficial on CPUs with a sane number of general
 115  * purpose registers which exclude the Intel x86.  On Intel, better let the
 116  * compiler actually reload registers directly from original memory by using
 117  * macros.
 118  */
 119
 120 /* replaced XPROD32 with a macro to avoid memory reference
 121    _x, _y are the results (must be l-values) */
 122 #define XPROD32(_a, _b, _t, _v, _x, _y) \
 123   { (_x)=MULT32(_a,_t)+MULT32(_b,_v);   \
 124     (_y)=MULT32(_b,_t)-MULT32(_a,_v); }
 125
 126
 127 #ifdef __i386__
 128
 129 #define XPROD31(_a, _b, _t, _v, _x, _y)  \
 130   { *(_x)=MULT31(_a,_t)+MULT31(_b,_v);   \
 131     *(_y)=MULT31(_b,_t)-MULT31(_a,_v); }
 132 #define XNPROD31(_a, _b, _t, _v, _x, _y) \
 133   { *(_x)=MULT31(_a,_t)-MULT31(_b,_v);   \
 134     *(_y)=MULT31(_b,_t)+MULT31(_a,_v); }
 135
 136 #else
 137
 138 static inline void XPROD31(ogg_int32_t  a, ogg_int32_t  b,
 139                            ogg_int32_t  t, ogg_int32_t  v,
 140                            ogg_int32_t *x, ogg_int32_t *y)
 141 {
 142   *x = MULT31(a, t) + MULT31(b, v);
 143   *y = MULT31(b, t) - MULT31(a, v);
 144 }
 145
 146 static inline void XNPROD31(ogg_int32_t  a, ogg_int32_t  b,
 147                             ogg_int32_t  t, ogg_int32_t  v,
 148                             ogg_int32_t *x, ogg_int32_t *y)
 149 {
 150   *x = MULT31(a, t) - MULT31(b, v);
 151   *y = MULT31(b, t) + MULT31(a, v);
 152 }
 153 #endif
 154
 155 #ifndef _V_VECT_OPS
 156 #define _V_VECT_OPS
 157
 158 /* generic misc.h has symmetrical versions of vect_add_right_left
 159    and vect_add_left_right  (since symmetrical versions of
 160    vect_mult_fw and vect_mult_bw  i.e.  both use MULT31) */
 161 static inline
 162 void vect_add_right_left(ogg_int32_t *x, const ogg_int32_t *y, int n)
 163 {
 164   while (n>0) {
 165     *x++ += *y++;
 166     n--;
 167   }
 168 }
 169
 170 static inline
 171 void vect_add_left_right(ogg_int32_t *x, const ogg_int32_t *y, int n)
 172 {
 173   vect_add_right_left(x,y,n);
 174 }
 175
 176 static inline
 177 void vect_mult_fw(ogg_int32_t *data, LOOKUP_T *window, int n)
 178 {
 179   while(n>0) {
 180     *data = MULT31(*data, *window);
 181     data++;
 182     window++;
 183     n--;
 184   }
 185 }
 186
 187 static inline
 188 void vect_mult_bw(ogg_int32_t *data, LOOKUP_T *window, int n)
 189 {
 190   while(n>0) {
 191     *data = MULT31(*data, *window);
 192     data++;
 193     window--;
 194     n--;
 195   }
 196 }
 197
 198 /* generic memcpy is probably optimal */
 199 static inline void vect_copy(ogg_int32_t *x, const ogg_int32_t *y, int n)
 200 {
 201   memcpy(x,y,n*sizeof(ogg_int32_t));
 202 }
 203 #endif
 204
 205 #endif
 206
 207 #ifndef _V_CLIP_MATH
 208 #define _V_CLIP_MATH
 209
 210 static inline ogg_int32_t CLIP_TO_15(ogg_int32_t x) {
 211   int ret=x;
 212   ret-= ((x<=32767)-1)&(x-32767);
 213   ret-= ((x>=-32768)-1)&(x+32768);
 214   return(ret);
 215 }
 216
 217 #endif
 218
 219 static inline ogg_int32_t VFLOAT_MULT(ogg_int32_t a,ogg_int32_t ap,
 220                                       ogg_int32_t b,ogg_int32_t bp,
 221                                       ogg_int32_t *p){
 222   if(a && b){
 223 #ifndef _LOW_ACCURACY_
 224     *p=ap+bp+32;
 225     return MULT32(a,b);
 226 #else
 227     *p=ap+bp+31;
 228     return (a>>15)*(b>>16);
 229 #endif
 230   }else
 231     return 0;
 232 }
 233
 234 static inline ogg_int32_t VFLOAT_MULTI(ogg_int32_t a,ogg_int32_t ap,
 235                                       ogg_int32_t i,
 236                                       ogg_int32_t *p){
 237
 238   int ip=_ilog(abs(i))-31;
 239   return VFLOAT_MULT(a,ap,i<<-ip,ip,p);
 240 }
 241
 242 static inline ogg_int32_t VFLOAT_ADD(ogg_int32_t a,ogg_int32_t ap,
 243                                       ogg_int32_t b,ogg_int32_t bp,
 244                                       ogg_int32_t *p){
 245
 246   if(!a){
 247     *p=bp;
 248     return b;
 249   }else if(!b){
 250     *p=ap;
 251     return a;
 252   }
 253
 254   /* yes, this can leak a bit. */
 255   if(ap>bp){
 256     int shift=ap-bp+1;
 257     *p=ap+1;
 258     a>>=1;
 259     if(shift<32){
 260       b=(b+(1<<(shift-1)))>>shift;
 261     }else{
 262       b=0;
 263     }
 264   }else{
 265     int shift=bp-ap+1;
 266     *p=bp+1;
 267     b>>=1;
 268     if(shift<32){
 269       a=(a+(1<<(shift-1)))>>shift;
 270     }else{
 271       a=0;
 272     }
 273   }
 274
 275   a+=b;
 276   if((a&0xc0000000)==0xc0000000 ||
 277      (a&0xc0000000)==0){
 278     a<<=1;
 279     (*p)--;
 280   }
 281   return(a);
 282 }
 283
 284 #endif
 285