开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
fixed.h
资源名称：Visual C++视频音频开发实用工程案例精选.rar　[点击查看]
上传用户：tuheem
上传日期：2007-05-01
资源大小：21889k
文件大小：10k
源码类别：

多媒体编程

开发平台：

Visual C++

fixed.h：源码内容
  1. /*
  2.  * libmad - MPEG audio decoder library
  3.  */
  5. # ifndef LIBMAD_FIXED_H
  6. # define LIBMAD_FIXED_H
  8. # if SIZEOF_INT >= 4
  9. typedef   signed int mad_fixed_t;
  11. typedef   signed int mad_fixed64hi_t;
  12. typedef unsigned int mad_fixed64lo_t;
  13. # else
  14. typedef   signed long mad_fixed_t;
  16. typedef   signed long mad_fixed64hi_t;
  17. typedef unsigned long mad_fixed64lo_t;
  18. # endif
  20. # if defined(_MSC_VER)
  21. #  define mad_fixed64_t  signed __int64
  22. # elif 1 || defined(__GNUC__)
  23. #  define mad_fixed64_t  signed long long
  24. # endif
  26. # if defined(FPM_FLOAT)
  27. typedef double mad_sample_t;
  28. # else
  29. typedef mad_fixed_t mad_sample_t;
  30. # endif
  34. # define MAD_F_FRACBITS 28
  36. # if MAD_F_FRACBITS == 28
  37. #  define MAD_F(x) ((mad_fixed_t) (x##L))
  38. # else
  39. #  if MAD_F_FRACBITS < 28
  40. #   warning "MAD_F_FRACBITS < 28"
  41. #   define MAD_F(x) ((mad_fixed_t)  
  42.  (((x##L) +  
  43.    (1L << (28 - MAD_F_FRACBITS - 1))) >>  
  44.   (28 - MAD_F_FRACBITS)))
  45. #  elif MAD_F_FRACBITS > 28
  46. #   error "MAD_F_FRACBITS > 28 not currently supported"
  47. #   define MAD_F(x) ((mad_fixed_t)  
  48.  ((x##L) << (MAD_F_FRACBITS - 28)))
  49. #  endif
  50. # endif
  52. # define MAD_F_MIN ((mad_fixed_t) -0x80000000L)
  53. # define MAD_F_MAX ((mad_fixed_t) +0x7fffffffL)
  55. # define MAD_F_ONE MAD_F(0x10000000)
  57. # define mad_f_tofixed(x) ((mad_fixed_t)  
  58.  ((x) * (double) (1L << MAD_F_FRACBITS) + 0.5))
  59. # define mad_f_todouble(x) ((double)  
  60.  ((x) / (double) (1L << MAD_F_FRACBITS)))
  62. # define mad_f_intpart(x) ((x) >> MAD_F_FRACBITS)
  63. # define mad_f_fracpart(x) ((x) & ((1L << MAD_F_FRACBITS) - 1))
  66. # define mad_f_fromint(x) ((x) << MAD_F_FRACBITS)
  68. # define mad_f_add(x, y) ((x) + (y))
  69. # define mad_f_sub(x, y) ((x) - (y))
  71. # if defined(FPM_FLOAT)
  72. #  error "FPM_FLOAT not yet supported"
  74. #  undef MAD_F
  75. #  define MAD_F(x) mad_f_todouble(x)
  77. #  define mad_f_mul(x, y) ((x) * (y))
  78. #  define mad_f_scale64
  80. #  undef ASO_ZEROCHECK
  82. # elif defined(FPM_64BIT)
  85. #  if defined(OPT_ACCURACY)
  86. #   define mad_f_mul(x, y)  
  87.     ((mad_fixed_t)  
  88.      ((((mad_fixed64_t) (x) * (y)) +  
  89.        (1L << (MAD_F_SCALEBITS - 1))) >> MAD_F_SCALEBITS))
  90. #  else
  91. #   define mad_f_mul(x, y)  
  92.     ((mad_fixed_t) (((mad_fixed64_t) (x) * (y)) >> MAD_F_SCALEBITS))
  93. #  endif
  95. #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
  97. /* --- Intel --------------------------------------------------------------- */
  99. # elif defined(FPM_INTEL)
  101. #  if defined(_MSC_VER)
  102. #   pragma warning(push)
  103. #   pragma warning(disable: 4035)  
  104. static __forceinline 
  105. mad_fixed_t mad_f_mul_inline(mad_fixed_t x, mad_fixed_t y)
  106. {
  107.   enum {
  108.     fracbits = MAD_F_FRACBITS
  109.   };
  111.   __asm {
  112.     mov eax, x
  113.     imul y
  114.     shrd eax, edx, fracbits
  115.   }
  118. }
  119. #   pragma warning(pop)
  121. #   define mad_f_mul mad_f_mul_inline
  122. #   define mad_f_scale64
  123. #  else
  125. #   define MAD_F_MLX(hi, lo, x, y)  
  126.     asm ("imull %3"  
  127.  : "=a" (lo), "=d" (hi)  
  128.  : "%a" (x), "rm" (y)  
  129.  : "cc")
  131. #   if defined(OPT_ACCURACY)
  133. #    define MAD_F_MLA(hi, lo, x, y)  
  134.     ({ mad_fixed64hi_t __hi;  
  135.        mad_fixed64lo_t __lo;  
  136.        MAD_F_MLX(__hi, __lo, (x), (y));  
  137.        asm ("addl %2,%0nt"  
  138.     "adcl %3,%1"  
  139.     : "=rm" (lo), "=rm" (hi)  
  140.     : "r" (__lo), "r" (__hi), "0" (lo), "1" (hi)  
  141.     : "cc");  
  142.     })
  143. #   endif  
  145. #   if defined(OPT_ACCURACY)
  147. #    define mad_f_scale64(hi, lo)  
  148.     ({ mad_fixed64hi_t __hi_;  
  149.        mad_fixed64lo_t __lo_;  
  150.        mad_fixed_t __result;  
  151.        asm ("addl %4,%2nt"  
  152.     "adcl %5,%3"  
  153.     : "=rm" (__lo_), "=rm" (__hi_)  
  154.     : "0" (lo), "1" (hi),  
  155.       "ir" (1L << (MAD_F_SCALEBITS - 1)), "ir" (0)  
  156.     : "cc");  
  157.        asm ("shrdl %3,%2,%1"  
  158.     : "=rm" (__result)  
  159.     : "0" (__lo_), "r" (__hi_), "I" (MAD_F_SCALEBITS)  
  160.     : "cc");  
  161.        __result;  
  162.     })
  163. #   else
  164. #    define mad_f_scale64(hi, lo)  
  165.     ({ mad_fixed_t __result;  
  166.        asm ("shrdl %3,%2,%1"  
  167.     : "=rm" (__result)  
  168.     : "0" (lo), "r" (hi), "I" (MAD_F_SCALEBITS)  
  169.     : "cc");  
  170.        __result;  
  171.     })
  172. #   endif  
  174. #   define MAD_F_SCALEBITS  MAD_F_FRACBITS
  175. #  endif
  177. /* --- ARM ----------------------------------------------------------------- */
  179. # elif defined(FPM_ARM)
  182. # if 1
  184. #  define mad_f_mul(x, y)  
  185.     ({ mad_fixed64hi_t __hi;  
  186.        mad_fixed64lo_t __lo;  
  187.        mad_fixed_t __result;  
  188.        asm ("smull %0, %1, %3, %4nt"  
  189.     "movs %0, %0, lsr %5nt"  
  190.     "adc %2, %0, %1, lsl %6"  
  191.     : "=&r" (__lo), "=&r" (__hi), "=r" (__result)  
  192.     : "%r" (x), "r" (y),  
  193.       "M" (MAD_F_SCALEBITS), "M" (32 - MAD_F_SCALEBITS)  
  194.     : "cc");  
  195.        __result;  
  196.     })
  197. # endif
  199. #  define MAD_F_MLX(hi, lo, x, y)  
  200.     asm ("smull %0, %1, %2, %3"  
  201.  : "=&r" (lo), "=&r" (hi)  
  202.  : "%r" (x), "r" (y))
  204. #  define MAD_F_MLA(hi, lo, x, y)  
  205.     asm ("smlal %0, %1, %2, %3"  
  206.  : "+r" (lo), "+r" (hi)  
  207.  : "%r" (x), "r" (y))
  209. #  define MAD_F_MLN(hi, lo)  
  210.     asm ("rsbs %0, %2, #0nt"  
  211.  "rsc %1, %3, #0"  
  212.  : "=r" (lo), "=r" (hi)  
  213.  : "0" (lo), "1" (hi)  
  214.  : "cc")
  216. #  define mad_f_scale64(hi, lo)  
  217.     ({ mad_fixed_t __result;  
  218.        asm ("movs %0, %1, lsr %3nt"  
  219.     "adc %0, %0, %2, lsl %4"  
  220.     : "=r" (__result)  
  221.     : "r" (lo), "r" (hi),  
  222.       "M" (MAD_F_SCALEBITS), "M" (32 - MAD_F_SCALEBITS)  
  223.     : "cc");  
  224.        __result;  
  225.     })
  227. #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
  229. /* --- MIPS ---------------------------------------------------------------- */
  231. # elif defined(FPM_MIPS)
  233. #  define MAD_F_MLX(hi, lo, x, y)  
  234.     asm ("mult %2,%3"  
  235.  : "=l" (lo), "=h" (hi)  
  236.  : "%r" (x), "r" (y))
  238. # if defined(HAVE_MADD_ASM)
  239. #  define MAD_F_MLA(hi, lo, x, y)  
  240.     asm ("madd %2,%3"  
  241.  : "+l" (lo), "+h" (hi)  
  242.  : "%r" (x), "r" (y))
  243. # elif defined(HAVE_MADD16_ASM)
  245. #  define MAD_F_ML0(hi, lo, x, y)  
  246.     asm ("mult %2,%3"  
  247.  : "=l" (lo), "=h" (hi)  
  248.  : "%r" ((x) >> 12), "r" ((y) >> 16))
  249. #  define MAD_F_MLA(hi, lo, x, y)  
  250.     asm ("madd16 %2,%3"  
  251.  : "+l" (lo), "+h" (hi)  
  252.  : "%r" ((x) >> 12), "r" ((y) >> 16))
  253. #  define MAD_F_MLZ(hi, lo)  ((mad_fixed_t) (lo))
  254. # endif
  256. # if defined(OPT_SPEED)
  257. #  define mad_f_scale64(hi, lo)  
  258.     ((mad_fixed_t) ((hi) << (32 - MAD_F_SCALEBITS)))
  259. #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
  260. # endif
  262. /* --- SPARC --------------------------------------------------------------- */
  264. # elif defined(FPM_SPARC)
  267. #  define MAD_F_MLX(hi, lo, x, y)  
  268.     asm ("smul %2, %3, %0nt"  
  269.  "rd %%y, %1"  
  270.  : "=r" (lo), "=r" (hi)  
  271.  : "%r" (x), "rI" (y))
  273. /* --- PowerPC ------------------------------------------------------------- */
  275. # elif defined(FPM_PPC)
  278. #  define MAD_F_MLX(hi, lo, x, y)  
  279.     asm ("mulhw %1, %2, %3nt"  
  280.  "mullw %0, %2, %3"  
  281.  : "=&r" (lo), "=&r" (hi)  
  282.  : "%r" (x), "r" (y))
  284. #  define MAD_F_MLA(hi, lo, x, y)  
  285.     ({ mad_fixed64hi_t __hi;  
  286.        mad_fixed64lo_t __lo;  
  287.        MAD_F_MLX(__hi, __lo, (x), (y));  
  288.        asm ("addc %0, %2, %3nt"  
  289.     "adde %1, %4, %5"  
  290.     : "=r" (lo), "=r" (hi)  
  291.     : "%r" (__lo), "0" (lo), "%r" (__hi), "1" (hi));  
  292.     })
  294. #  if defined(OPT_ACCURACY)
  296. #   define mad_f_scale64(hi, lo)  
  297.     ({ mad_fixed_t __result;  
  298.        mad_fixed64hi_t __hi_;  
  299.        mad_fixed64lo_t __lo_;  
  300.        asm __volatile__ ("addc %0, %2, %4nt"  
  301.  "addze %1, %3"  
  302.     : "=r" (__lo_), "=r" (__hi_)  
  303.     : "r" (lo), "r" (hi), "r" (1 << (MAD_F_SCALEBITS - 1)));  
  304.        asm __volatile__ ("rlwinm %0, %2,32-%3,0,%3-1nt"  
  305.  "rlwimi %0, %1,32-%3,%3,31"  
  306.     : "=&r" (__result)  
  307.     : "r" (__lo_), "r" (__hi_), "I" (MAD_F_SCALEBITS));  
  308.     __result;  
  309.     })
  310. #  else
  311. #   define mad_f_scale64(hi, lo)  
  312.     ({ mad_fixed_t __result;  
  313.        asm ("rlwinm %0, %2,32-%3,0,%3-1nt"  
  314.     "rlwimi %0, %1,32-%3,%3,31"  
  315.     : "=r" (__result)  
  316.     : "r" (lo), "r" (hi), "I" (MAD_F_SCALEBITS));  
  317.     __result;  
  318.     })
  319. #  endif  
  321. #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
  323. /* --- Default ------------------------------------------------------------- */
  325. # elif defined(FPM_DEFAULT)
  328. #  if defined(OPT_SPEED)
  329. #   define mad_f_mul(x, y) (((x) >> 12) * ((y) >> 16))
  330. #  else
  331. #   define mad_f_mul(x, y) ((((x) + (1L << 11)) >> 12) *  
  332.  (((y) + (1L << 15)) >> 16))
  333. #  endif
  335. /* ------------------------------------------------------------------------- */
  337. # else
  338. #  error "no FPM selected"
  339. # endif
  343. # if !defined(mad_f_mul)
  344. #  define mad_f_mul(x, y)  
  345.     ({ mad_fixed64hi_t __hi;  
  346.        mad_fixed64lo_t __lo;  
  347.        MAD_F_MLX(__hi, __lo, (x), (y));  
  348.        mad_f_scale64(__hi, __lo);  
  349.     })
  350. # endif
  352. # if !defined(MAD_F_MLA)
  353. #  define MAD_F_ML0(hi, lo, x, y) ((lo)  = mad_f_mul((x), (y)))
  354. #  define MAD_F_MLA(hi, lo, x, y) ((lo) += mad_f_mul((x), (y)))
  355. #  define MAD_F_MLN(hi, lo) ((lo)  = -(lo))
  356. #  define MAD_F_MLZ(hi, lo) ((void) (hi), (mad_fixed_t) (lo))
  357. # endif
  359. # if !defined(MAD_F_ML0)
  360. #  define MAD_F_ML0(hi, lo, x, y) MAD_F_MLX((hi), (lo), (x), (y))
  361. # endif
  363. # if !defined(MAD_F_MLN)
  364. #  define MAD_F_MLN(hi, lo) ((hi) = ((lo) = -(lo)) ? ~(hi) : -(hi))
  365. # endif
  367. # if !defined(MAD_F_MLZ)
  368. #  define MAD_F_MLZ(hi, lo) mad_f_scale64((hi), (lo))
  369. # endif
  371. # if !defined(mad_f_scale64)
  372. #  if defined(OPT_ACCURACY)
  373. #   define mad_f_scale64(hi, lo)  
  374.     ((((mad_fixed_t)  
  375.        (((hi) << (32 - (MAD_F_SCALEBITS - 1))) |  
  376. ((lo) >> (MAD_F_SCALEBITS - 1)))) + 1) >> 1)
  377. #  else
  378. #   define mad_f_scale64(hi, lo)  
  379.     ((mad_fixed_t)  
  380.      (((hi) << (32 - MAD_F_SCALEBITS)) |  
  381.       ((lo) >> MAD_F_SCALEBITS)))
  382. #  endif
  383. #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
  384. # endif
  388. mad_fixed_t mad_f_abs(mad_fixed_t);
  390. # endif