text: /************************************************************************
   * Copyright (C) 2002-2009, Xiph.org Foundation
   * Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   *     * Redistributions of source code must retain the above copyright
   * notice, this list of conditions and the following disclaimer.
   *     * Redistributions in binary form must reproduce the above
   * copyright notice, this list of conditions and the following disclaimer
   * in the documentation and/or other materials provided with the
   * distribution.
   *     * Neither the names of the Xiph.org Foundation nor Pinknoise
   * Productions Ltd nor the names of its contributors may be used to
   * endorse or promote products derived from this software without
   * specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   ************************************************************************
  
   function: miscellaneous math and prototypes
  
   ************************************************************************/
  
  #ifndef _V_RANDOM_H_
  #define _V_RANDOM_H_
  #include "ivorbiscodec.h"
  #include "os_types.h"
  
  /*#define _VDBG_GRAPHFILE "_0.m"*/
  
  
  #ifdef _VDBG_GRAPHFILE
  extern void *_VDBG_malloc(void *ptr,long bytes,char *file,long line);
  extern void _VDBG_free(void *ptr);
  
  #undef _ogg_malloc
  #undef _ogg_calloc
  #undef _ogg_realloc
  #undef _ogg_free
  
  #define _ogg_malloc(x) _VDBG_malloc(NULL,(x),__FILE__,__LINE__)
  #define _ogg_calloc(x,y) _VDBG_malloc(NULL,(x)*(y),__FILE__,__LINE__)
  #define _ogg_realloc(x,y) _VDBG_malloc((x),(y),__FILE__,__LINE__)
  #define _ogg_free(x) _VDBG_free((x))
  #endif
  
  #include "asm_arm.h"
  
  #ifndef _V_WIDE_MATH
  #define _V_WIDE_MATH
  
  #ifndef  _LOW_ACCURACY_
  /* 64 bit multiply */
  
  #include <endian.h>
  #include <sys/types.h>
  
  #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
  
  static inline 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;
  }
  
  static inline ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) {
    return MULT32(x,y)<<1;
  }
  
  static inline 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.
   */
  
  static inline ogg_int32_t MULT32(ogg_int32_t x, ogg_int32_t y) {
    return (x >> 9) * y;  /* y preshifted >>23 */
  }
  
  static inline ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) {
    return (x >> 8) * y;  /* y preshifted >>23 */
  }
  
  static inline 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
  
  static inline 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);
  }
  
  static inline 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);
  }
  
  static inline 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
  
  static inline 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
  
  #endif
  
  
  
  
  