libmad: fixed.h Source File

00001 /*
00002  * libmad - MPEG audio decoder library
00003  * Copyright (C) 2000-2008 Underbit Technologies, Inc.
00004  *
00005  * This program is free software; you can redistribute it and/or modify
00006  * it under the terms of the GNU General Public License as published by
00007  * the Free Software Foundation; either version 2 of the License, or
00008  * (at your option) any later version.
00009  *
00010  * This program is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  * GNU General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU General Public License
00016  * along with this program; if not, write to the Free Software
00017  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00018  *
00019  * $Id: fixed.h 88 2008-06-09 11:59:11Z mich $
00020  */
00021 
00022 # ifndef LIBMAD_FIXED_H
00023 # define LIBMAD_FIXED_H
00024 
00025 # if SIZEOF_INT >= 4
00026 typedef   signed int mad_fixed_t;
00027 
00028 typedef   signed int mad_fixed64hi_t;
00029 typedef unsigned int mad_fixed64lo_t;
00030 # else
00031 typedef   signed long mad_fixed_t;
00032 
00033 typedef   signed long mad_fixed64hi_t;
00034 typedef unsigned long mad_fixed64lo_t;
00035 # endif
00036 
00037 # if defined(_MSC_VER)
00038 #  define mad_fixed64_t  signed __int64
00039 # elif 1 || defined(__GNUC__)
00040 #  define mad_fixed64_t  signed long long
00041 # endif
00042 
00043 # if defined(FPM_FLOAT)
00044 typedef double mad_sample_t;
00045 # else
00046 typedef mad_fixed_t mad_sample_t;
00047 # endif
00048 
00082 # define MAD_F_FRACBITS         28
00083 
00084 # if MAD_F_FRACBITS == 28
00085 #  define MAD_F(x)              ((mad_fixed_t) (x##L))
00086 # else
00087 #  if MAD_F_FRACBITS < 28
00088 #   warning "MAD_F_FRACBITS < 28"
00089 #   define MAD_F(x)             ((mad_fixed_t)  \
00090                                  (((x##L) +  \
00091                                    (1L << (28 - MAD_F_FRACBITS - 1))) >>  \
00092                                   (28 - MAD_F_FRACBITS)))
00093 #  elif MAD_F_FRACBITS > 28
00094 #   error "MAD_F_FRACBITS > 28 not currently supported"
00095 #   define MAD_F(x)             ((mad_fixed_t)  \
00096                                  ((x##L) << (MAD_F_FRACBITS - 28)))
00097 #  endif
00098 # endif
00099 
00100 # define MAD_F_MIN              ((mad_fixed_t) -0x80000000L)
00101 # define MAD_F_MAX              ((mad_fixed_t) +0x7fffffffL)
00102 
00103 # define MAD_F_ONE              MAD_F(0x10000000)
00104 
00105 # define mad_f_tofixed(x)       ((mad_fixed_t)  \
00106                                  ((x) * (double) (1L << MAD_F_FRACBITS) + 0.5))
00107 # define mad_f_todouble(x)      ((double)  \
00108                                  ((x) / (double) (1L << MAD_F_FRACBITS)))
00109 
00110 # define mad_f_intpart(x)       ((x) >> MAD_F_FRACBITS)
00111 # define mad_f_fracpart(x)      ((x) & ((1L << MAD_F_FRACBITS) - 1))
00112                                 /* (x should be positive) */
00113 
00114 # define mad_f_fromint(x)       ((x) << MAD_F_FRACBITS)
00115 
00116 # define mad_f_add(x, y)        ((x) + (y))
00117 # define mad_f_sub(x, y)        ((x) - (y))
00118 
00119 # if defined(FPM_FLOAT)
00120 #  error "FPM_FLOAT not yet supported"
00121 
00122 #  undef MAD_F
00123 #  define MAD_F(x)              mad_f_todouble(x)
00124 
00125 #  define mad_f_mul(x, y)       ((x) * (y))
00126 #  define mad_f_scale64
00127 
00128 #  undef ASO_ZEROCHECK
00129 
00130 # elif defined(FPM_64BIT)
00131 
00136 #  if defined(OPT_ACCURACY)
00137 #   define mad_f_mul(x, y)  \
00138     ((mad_fixed_t)  \
00139      ((((mad_fixed64_t) (x) * (y)) +  \
00140        (1L << (MAD_F_SCALEBITS - 1))) >> MAD_F_SCALEBITS))
00141 #  else
00142 #   define mad_f_mul(x, y)  \
00143     ((mad_fixed_t) (((mad_fixed64_t) (x) * (y)) >> MAD_F_SCALEBITS))
00144 #  endif
00145 
00146 #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
00147 
00148 /* --- Intel --------------------------------------------------------------- */
00149 
00150 # elif defined(FPM_INTEL)
00151 
00152 #  if defined(_MSC_VER)
00153 #   pragma warning(push)
00154 #   pragma warning(disable: 4035)  /* no return value */
00155 static __forceinline
00156 mad_fixed_t mad_f_mul_inline(mad_fixed_t x, mad_fixed_t y)
00157 {
00158   enum {
00159     fracbits = MAD_F_FRACBITS
00160   };
00161 
00162   __asm {
00163     mov eax, x
00164     imul y
00165     shrd eax, edx, fracbits
00166   }
00167 
00168   /* implicit return of eax */
00169 }
00170 #   pragma warning(pop)
00171 
00172 #   define mad_f_mul            mad_f_mul_inline
00173 #   define mad_f_scale64
00174 #  else
00175 /*
00176  * This Intel version is fast and accurate; the disposition of the least
00177  * significant bit depends on OPT_ACCURACY via mad_f_scale64().
00178  */
00179 #   define MAD_F_MLX(hi, lo, x, y)  \
00180     asm ("imull %3"  \
00181          : "=a" (lo), "=d" (hi)  \
00182          : "%a" (x), "rm" (y)  \
00183          : "cc")
00184 
00185 #   if defined(OPT_ACCURACY)
00186 /*
00187  * This gives best accuracy but is not very fast.
00188  */
00189 #    define MAD_F_MLA(hi, lo, x, y)  \
00190     ({ mad_fixed64hi_t __hi;  \
00191        mad_fixed64lo_t __lo;  \
00192        MAD_F_MLX(__hi, __lo, (x), (y));  \
00193        asm ("addl %2,%0\n\t"  \
00194             "adcl %3,%1"  \
00195             : "=rm" (lo), "=rm" (hi)  \
00196             : "r" (__lo), "r" (__hi), "0" (lo), "1" (hi)  \
00197             : "cc");  \
00198     })
00199 #   endif  /* OPT_ACCURACY */
00200 
00201 #   if defined(OPT_ACCURACY)
00202 /*
00203  * Surprisingly, this is faster than SHRD followed by ADC.
00204  */
00205 #    define mad_f_scale64(hi, lo)  \
00206     ({ mad_fixed64hi_t __hi_;  \
00207        mad_fixed64lo_t __lo_;  \
00208        mad_fixed_t __result;  \
00209        asm ("addl %4,%2\n\t"  \
00210             "adcl %5,%3"  \
00211             : "=rm" (__lo_), "=rm" (__hi_)  \
00212             : "0" (lo), "1" (hi),  \
00213               "ir" (1L << (MAD_F_SCALEBITS - 1)), "ir" (0)  \
00214             : "cc");  \
00215        asm ("shrdl %3,%2,%1"  \
00216             : "=rm" (__result)  \
00217             : "0" (__lo_), "r" (__hi_), "I" (MAD_F_SCALEBITS)  \
00218             : "cc");  \
00219        __result;  \
00220     })
00221 #   elif defined(OPT_INTEL)
00222 /*
00223  * Alternate Intel scaling that may or may not perform better.
00224  */
00225 #    define mad_f_scale64(hi, lo)  \
00226     ({ mad_fixed_t __result;  \
00227        asm ("shrl %3,%1\n\t"  \
00228             "shll %4,%2\n\t"  \
00229             "orl %2,%1"  \
00230             : "=rm" (__result)  \
00231             : "0" (lo), "r" (hi),  \
00232               "I" (MAD_F_SCALEBITS), "I" (32 - MAD_F_SCALEBITS)  \
00233             : "cc");  \
00234        __result;  \
00235     })
00236 #   else
00237 #    define mad_f_scale64(hi, lo)  \
00238     ({ mad_fixed_t __result;  \
00239        asm ("shrdl %3,%2,%1"  \
00240             : "=rm" (__result)  \
00241             : "0" (lo), "r" (hi), "I" (MAD_F_SCALEBITS)  \
00242             : "cc");  \
00243        __result;  \
00244     })
00245 #   endif  /* OPT_ACCURACY */
00246 
00247 #   define MAD_F_SCALEBITS  MAD_F_FRACBITS
00248 #  endif
00249 
00250 /* --- ARM ----------------------------------------------------------------- */
00251 
00252 # elif defined(FPM_ARM)
00253 
00254 /* 
00255  * This ARM V4 version is as accurate as FPM_64BIT but much faster. The
00256  * least significant bit is properly rounded at no CPU cycle cost!
00257  */
00258 # if 1
00259 /*
00260  * This is faster than the default implementation via MAD_F_MLX() and
00261  * mad_f_scale64().
00262  */
00263 #  define mad_f_mul(x, y)  \
00264     ({ mad_fixed64hi_t __hi;  \
00265        mad_fixed64lo_t __lo;  \
00266        mad_fixed_t __result;  \
00267        asm ("smull      %0, %1, %3, %4\n\t"  \
00268             "movs       %0, %0, lsr %5\n\t"  \
00269             "adc        %2, %0, %1, lsl %6"  \
00270             : "=&r" (__lo), "=&r" (__hi), "=r" (__result)  \
00271             : "%r" (x), "r" (y),  \
00272               "M" (MAD_F_SCALEBITS), "M" (32 - MAD_F_SCALEBITS)  \
00273             : "cc");  \
00274        __result;  \
00275     })
00276 # endif
00277 
00278 #  define MAD_F_MLX(hi, lo, x, y)  \
00279     asm ("smull %0, %1, %2, %3"  \
00280          : "=&r" (lo), "=&r" (hi)  \
00281          : "%r" (x), "r" (y))
00282 
00283 #  define MAD_F_MLA(hi, lo, x, y)  \
00284     asm ("smlal %0, %1, %2, %3"  \
00285          : "+r" (lo), "+r" (hi)  \
00286          : "%r" (x), "r" (y))
00287 
00288 #  define MAD_F_MLN(hi, lo)  \
00289     asm ("rsbs  %0, %2, #0\n\t"  \
00290          "rsc   %1, %3, #0"  \
00291          : "=r" (lo), "=r" (hi)  \
00292          : "0" (lo), "1" (hi)  \
00293          : "cc")
00294 
00295 #  define mad_f_scale64(hi, lo)  \
00296     ({ mad_fixed_t __result;  \
00297        asm ("movs       %0, %1, lsr %3\n\t"  \
00298             "adc        %0, %0, %2, lsl %4"  \
00299             : "=&r" (__result)  \
00300             : "r" (lo), "r" (hi),  \
00301               "M" (MAD_F_SCALEBITS), "M" (32 - MAD_F_SCALEBITS)  \
00302             : "cc");  \
00303        __result;  \
00304     })
00305 
00306 #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
00307 
00308 /* --- MIPS ---------------------------------------------------------------- */
00309 
00310 # elif defined(FPM_MIPS)
00311 
00312 /*
00313  * This MIPS version is fast and accurate; the disposition of the least
00314  * significant bit depends on OPT_ACCURACY via mad_f_scale64().
00315  */
00316 #  define MAD_F_MLX(hi, lo, x, y)  \
00317     asm ("mult  %2,%3"  \
00318          : "=l" (lo), "=h" (hi)  \
00319          : "%r" (x), "r" (y))
00320 
00321 # if defined(HAVE_MADD_ASM)
00322 #  define MAD_F_MLA(hi, lo, x, y)  \
00323     asm ("madd  %2,%3"  \
00324          : "+l" (lo), "+h" (hi)  \
00325          : "%r" (x), "r" (y))
00326 # elif defined(HAVE_MADD16_ASM)
00327 /*
00328  * This loses significant accuracy due to the 16-bit integer limit in the
00329  * multiply/accumulate instruction.
00330  */
00331 #  define MAD_F_ML0(hi, lo, x, y)  \
00332     asm ("mult  %2,%3"  \
00333          : "=l" (lo), "=h" (hi)  \
00334          : "%r" ((x) >> 12), "r" ((y) >> 16))
00335 #  define MAD_F_MLA(hi, lo, x, y)  \
00336     asm ("madd16        %2,%3"  \
00337          : "+l" (lo), "+h" (hi)  \
00338          : "%r" ((x) >> 12), "r" ((y) >> 16))
00339 #  define MAD_F_MLZ(hi, lo)  ((mad_fixed_t) (lo))
00340 # endif
00341 
00342 # if defined(OPT_SPEED)
00343 #  define mad_f_scale64(hi, lo)  \
00344     ((mad_fixed_t) ((hi) << (32 - MAD_F_SCALEBITS)))
00345 #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
00346 # endif
00347 
00348 /* --- SPARC --------------------------------------------------------------- */
00349 
00350 # elif defined(FPM_SPARC)
00351 
00352 /*
00353  * This SPARC V8 version is fast and accurate; the disposition of the least
00354  * significant bit depends on OPT_ACCURACY via mad_f_scale64().
00355  */
00356 #  define MAD_F_MLX(hi, lo, x, y)  \
00357     asm ("smul %2, %3, %0\n\t"  \
00358          "rd %%y, %1"  \
00359          : "=r" (lo), "=r" (hi)  \
00360          : "%r" (x), "rI" (y))
00361 
00362 /* --- PowerPC ------------------------------------------------------------- */
00363 
00364 # elif defined(FPM_PPC)
00365 
00366 /*
00367  * This PowerPC version is fast and accurate; the disposition of the least
00368  * significant bit depends on OPT_ACCURACY via mad_f_scale64().
00369  */
00370 #  define MAD_F_MLX(hi, lo, x, y)  \
00371     do {  \
00372       asm ("mullw %0,%1,%2"  \
00373            : "=r" (lo)  \
00374            : "%r" (x), "r" (y));  \
00375       asm ("mulhw %0,%1,%2"  \
00376            : "=r" (hi)  \
00377            : "%r" (x), "r" (y));  \
00378     }  \
00379     while (0)
00380 
00381 #  if defined(OPT_ACCURACY)
00382 /*
00383  * This gives best accuracy but is not very fast.
00384  */
00385 #   define MAD_F_MLA(hi, lo, x, y)  \
00386     ({ mad_fixed64hi_t __hi;  \
00387        mad_fixed64lo_t __lo;  \
00388        MAD_F_MLX(__hi, __lo, (x), (y));  \
00389        asm ("addc %0,%2,%3\n\t"  \
00390             "adde %1,%4,%5"  \
00391             : "=r" (lo), "=r" (hi)  \
00392             : "%r" (lo), "r" (__lo),  \
00393               "%r" (hi), "r" (__hi)  \
00394             : "xer");  \
00395     })
00396 #  endif
00397 
00398 #  if defined(OPT_ACCURACY)
00399 /*
00400  * This is slower than the truncating version below it.
00401  */
00402 #   define mad_f_scale64(hi, lo)  \
00403     ({ mad_fixed_t __result, __round;  \
00404        asm ("rotrwi %0,%1,%2"  \
00405             : "=r" (__result)  \
00406             : "r" (lo), "i" (MAD_F_SCALEBITS));  \
00407        asm ("extrwi %0,%1,1,0"  \
00408             : "=r" (__round)  \
00409             : "r" (__result));  \
00410        asm ("insrwi %0,%1,%2,0"  \
00411             : "+r" (__result)  \
00412             : "r" (hi), "i" (MAD_F_SCALEBITS));  \
00413        asm ("add %0,%1,%2"  \
00414             : "=r" (__result)  \
00415             : "%r" (__result), "r" (__round));  \
00416        __result;  \
00417     })
00418 #  else
00419 #   define mad_f_scale64(hi, lo)  \
00420     ({ mad_fixed_t __result;  \
00421        asm ("rotrwi %0,%1,%2"  \
00422             : "=r" (__result)  \
00423             : "r" (lo), "i" (MAD_F_SCALEBITS));  \
00424        asm ("insrwi %0,%1,%2,0"  \
00425             : "+r" (__result)  \
00426             : "r" (hi), "i" (MAD_F_SCALEBITS));  \
00427        __result;  \
00428     })
00429 #  endif
00430 
00431 #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
00432 
00433 /* --- Default ------------------------------------------------------------- */
00434 
00435 # elif defined(FPM_DEFAULT)
00436 
00437 /*
00438  * This version is the most portable but it loses significant accuracy.
00439  * Furthermore, accuracy is biased against the second argument, so care
00440  * should be taken when ordering operands.
00441  *
00442  * The scale factors are constant as this is not used with SSO.
00443  *
00444  * Pre-rounding is required to stay within the limits of compliance.
00445  */
00446 #  if defined(OPT_SPEED)
00447 #   define mad_f_mul(x, y)      (((x) >> 12) * ((y) >> 16))
00448 #  else
00449 #   define mad_f_mul(x, y)      ((((x) + (1L << 11)) >> 12) *  \
00450                                  (((y) + (1L << 15)) >> 16))
00451 #  endif
00452 
00453 /* ------------------------------------------------------------------------- */
00454 
00455 # else
00456 #  error "no FPM selected"
00457 # endif
00458 
00459 /* default implementations */
00460 
00461 # if !defined(mad_f_mul)
00462 #  define mad_f_mul(x, y)  \
00463     ({ register mad_fixed64hi_t __hi;  \
00464        register mad_fixed64lo_t __lo;  \
00465        MAD_F_MLX(__hi, __lo, (x), (y));  \
00466        mad_f_scale64(__hi, __lo);  \
00467     })
00468 # endif
00469 
00470 # if !defined(MAD_F_MLA)
00471 #  define MAD_F_ML0(hi, lo, x, y)       ((lo)  = mad_f_mul((x), (y)))
00472 #  define MAD_F_MLA(hi, lo, x, y)       ((lo) += mad_f_mul((x), (y)))
00473 #  define MAD_F_MLN(hi, lo)             ((lo)  = -(lo))
00474 #  define MAD_F_MLZ(hi, lo)             ((void) (hi), (mad_fixed_t) (lo))
00475 # endif
00476 
00477 # if !defined(MAD_F_ML0)
00478 #  define MAD_F_ML0(hi, lo, x, y)       MAD_F_MLX((hi), (lo), (x), (y))
00479 # endif
00480 
00481 # if !defined(MAD_F_MLN)
00482 #  define MAD_F_MLN(hi, lo)             ((hi) = ((lo) = -(lo)) ? ~(hi) : -(hi))
00483 # endif
00484 
00485 # if !defined(MAD_F_MLZ)
00486 #  define MAD_F_MLZ(hi, lo)             mad_f_scale64((hi), (lo))
00487 # endif
00488 
00489 # if !defined(mad_f_scale64)
00490 #  if defined(OPT_ACCURACY)
00491 #   define mad_f_scale64(hi, lo)  \
00492     ((((mad_fixed_t)  \
00493        (((hi) << (32 - (MAD_F_SCALEBITS - 1))) |  \
00494         ((lo) >> (MAD_F_SCALEBITS - 1)))) + 1) >> 1)
00495 #  else
00496 #   define mad_f_scale64(hi, lo)  \
00497     ((mad_fixed_t)  \
00498      (((hi) << (32 - MAD_F_SCALEBITS)) |  \
00499       ((lo) >> MAD_F_SCALEBITS)))
00500 #  endif
00501 #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
00502 # endif
00503 
00504 /* C routines */
00505 
00506 mad_fixed_t mad_f_abs(mad_fixed_t);
00507 mad_fixed_t mad_f_div(mad_fixed_t, mad_fixed_t);
00508 
00509 # endif