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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
cfft.c
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：35k
源码类别：

多媒体编程

开发平台：

Visual C++

cfft.c：源码内容
  1. /*
  2. ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
  3. ** Copyright (C) 2003-2005 M. Bakker, Ahead Software AG, http://www.nero.com
  4. **  
  5. ** This program is free software; you can redistribute it and/or modify
  6. ** it under the terms of the GNU General Public License as published by
  7. ** the Free Software Foundation; either version 2 of the License, or
  8. ** (at your option) any later version.
  9. ** 
  10. ** This program is distributed in the hope that it will be useful,
  11. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. ** GNU General Public License for more details.
  14. ** 
  15. ** You should have received a copy of the GNU General Public License
  16. ** along with this program; if not, write to the Free Software 
  17. ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18. **
  19. ** Any non-GPL usage of this software or parts of this software is strictly
  20. ** forbidden.
  21. **
  22. ** Software using this code must display the following message visibly in the
  23. ** software:
  24. ** "FAAD2 AAC/HE-AAC/HE-AACv2/DRM decoder (c) Ahead Software, www.nero.com"
  25. ** in, for example, the about-box or help/startup screen.
  26. **
  27. ** Commercial non-GPL licensing of this software is possible.
  28. ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
  29. **
  30. ** $Id: cfft.c,v 1.2 2005/11/01 21:41:43 gabest Exp $
  31. **/
  33. /*
  34.  * Algorithmically based on Fortran-77 FFTPACK
  35.  * by Paul N. Swarztrauber(Version 4, 1985).
  36.  *
  37.  * Does even sized fft only
  38.  */
  40. /* isign is +1 for backward and -1 for forward transforms */
  42. #include "common.h"
  43. #include "structs.h"
  45. #include <stdlib.h>
  47. #include "cfft.h"
  48. #include "cfft_tab.h"
  51. /* static function declarations */
  52. static void passf2pos(const uint16_t ido, const uint16_t l1, const complex_t *cc,
  53.                       complex_t *ch, const complex_t *wa);
  54. static void passf2neg(const uint16_t ido, const uint16_t l1, const complex_t *cc,
  55.                       complex_t *ch, const complex_t *wa);
  56. static void passf3(const uint16_t ido, const uint16_t l1, const complex_t *cc,
  57.                    complex_t *ch, const complex_t *wa1, const complex_t *wa2, const int8_t isign);
  58. static void passf4pos(const uint16_t ido, const uint16_t l1, const complex_t *cc, complex_t *ch,
  59.                       const complex_t *wa1, const complex_t *wa2, const complex_t *wa3);
  60. static void passf4neg(const uint16_t ido, const uint16_t l1, const complex_t *cc, complex_t *ch,
  61.                       const complex_t *wa1, const complex_t *wa2, const complex_t *wa3);
  62. static void passf5(const uint16_t ido, const uint16_t l1, const complex_t *cc, complex_t *ch,
  63.                    const complex_t *wa1, const complex_t *wa2, const complex_t *wa3,
  64.                    const complex_t *wa4, const int8_t isign);
  65. INLINE void cfftf1(uint16_t n, complex_t *c, complex_t *ch,
  66.                    const uint16_t *ifac, const complex_t *wa, const int8_t isign);
  67. static void cffti1(uint16_t n, complex_t *wa, uint16_t *ifac);
  70. /*----------------------------------------------------------------------
  71.    passf2, passf3, passf4, passf5. Complex FFT passes fwd and bwd.
  72.   ----------------------------------------------------------------------*/
  74. static void passf2pos(const uint16_t ido, const uint16_t l1, const complex_t *cc,
  75.                       complex_t *ch, const complex_t *wa)
  76. {
  77.     uint16_t i, k, ah, ac;
  79.     if (ido == 1)
  80.     {
  81.         for (k = 0; k < l1; k++)
  82.         {
  83.             ah = 2*k;
  84.             ac = 4*k;
  86.             RE(ch[ah])    = RE(cc[ac]) + RE(cc[ac+1]);
  87.             RE(ch[ah+l1]) = RE(cc[ac]) - RE(cc[ac+1]);
  88.             IM(ch[ah])    = IM(cc[ac]) + IM(cc[ac+1]);
  89.             IM(ch[ah+l1]) = IM(cc[ac]) - IM(cc[ac+1]);
  90.         }
  91.     } else {
  92.         for (k = 0; k < l1; k++)
  93.         {
  94.             ah = k*ido;
  95.             ac = 2*k*ido;
  97.             for (i = 0; i < ido; i++)
  98.             {
  99.                 complex_t t2;
  101.                 RE(ch[ah+i]) = RE(cc[ac+i]) + RE(cc[ac+i+ido]);
  102.                 RE(t2)       = RE(cc[ac+i]) - RE(cc[ac+i+ido]);
  104.                 IM(ch[ah+i]) = IM(cc[ac+i]) + IM(cc[ac+i+ido]);
  105.                 IM(t2)       = IM(cc[ac+i]) - IM(cc[ac+i+ido]);
  107. #if 1
  108.                 ComplexMult(&IM(ch[ah+i+l1*ido]), &RE(ch[ah+i+l1*ido]),
  109.                     IM(t2), RE(t2), RE(wa[i]), IM(wa[i]));
  110. #else
  111.                 ComplexMult(&RE(ch[ah+i+l1*ido]), &IM(ch[ah+i+l1*ido]),
  112.                     RE(t2), IM(t2), RE(wa[i]), IM(wa[i]));
  113. #endif
  114.             }
  115.         }
  116.     }
  117. }
  119. static void passf2neg(const uint16_t ido, const uint16_t l1, const complex_t *cc,
  120.                       complex_t *ch, const complex_t *wa)
  121. {
  122.     uint16_t i, k, ah, ac;
  124.     if (ido == 1)
  125.     {
  126.         for (k = 0; k < l1; k++)
  127.         {
  128.             ah = 2*k;
  129.             ac = 4*k;
  131.             RE(ch[ah])    = RE(cc[ac]) + RE(cc[ac+1]);
  132.             RE(ch[ah+l1]) = RE(cc[ac]) - RE(cc[ac+1]);
  133.             IM(ch[ah])    = IM(cc[ac]) + IM(cc[ac+1]);
  134.             IM(ch[ah+l1]) = IM(cc[ac]) - IM(cc[ac+1]);
  135.         }
  136.     } else {
  137.         for (k = 0; k < l1; k++)
  138.         {
  139.             ah = k*ido;
  140.             ac = 2*k*ido;
  142.             for (i = 0; i < ido; i++)
  143.             {
  144.                 complex_t t2;
  146.                 RE(ch[ah+i]) = RE(cc[ac+i]) + RE(cc[ac+i+ido]);
  147.                 RE(t2)       = RE(cc[ac+i]) - RE(cc[ac+i+ido]);
  149.                 IM(ch[ah+i]) = IM(cc[ac+i]) + IM(cc[ac+i+ido]);
  150.                 IM(t2)       = IM(cc[ac+i]) - IM(cc[ac+i+ido]);
  152. #if 1
  153.                 ComplexMult(&RE(ch[ah+i+l1*ido]), &IM(ch[ah+i+l1*ido]),
  154.                     RE(t2), IM(t2), RE(wa[i]), IM(wa[i]));
  155. #else
  156.                 ComplexMult(&IM(ch[ah+i+l1*ido]), &RE(ch[ah+i+l1*ido]),
  157.                     IM(t2), RE(t2), RE(wa[i]), IM(wa[i]));
  158. #endif
  159.             }
  160.         }
  161.     }
  162. }
  165. static void passf3(const uint16_t ido, const uint16_t l1, const complex_t *cc,
  166.                    complex_t *ch, const complex_t *wa1, const complex_t *wa2,
  167.                    const int8_t isign)
  168. {
  169.     static real_t taur = FRAC_CONST(-0.5);
  170.     static real_t taui = FRAC_CONST(0.866025403784439);
  171.     uint16_t i, k, ac, ah;
  172.     complex_t c2, c3, d2, d3, t2;
  174.     if (ido == 1)
  175.     {
  176.         if (isign == 1)
  177.         {
  178.             for (k = 0; k < l1; k++)
  179.             {
  180.                 ac = 3*k+1;
  181.                 ah = k;
  183.                 RE(t2) = RE(cc[ac]) + RE(cc[ac+1]);
  184.                 IM(t2) = IM(cc[ac]) + IM(cc[ac+1]);
  185.                 RE(c2) = RE(cc[ac-1]) + MUL_F(RE(t2),taur);
  186.                 IM(c2) = IM(cc[ac-1]) + MUL_F(IM(t2),taur);
  188.                 RE(ch[ah]) = RE(cc[ac-1]) + RE(t2);
  189.                 IM(ch[ah]) = IM(cc[ac-1]) + IM(t2);
  191.                 RE(c3) = MUL_F((RE(cc[ac]) - RE(cc[ac+1])), taui);
  192.                 IM(c3) = MUL_F((IM(cc[ac]) - IM(cc[ac+1])), taui);
  194.                 RE(ch[ah+l1]) = RE(c2) - IM(c3);
  195.                 IM(ch[ah+l1]) = IM(c2) + RE(c3);
  196.                 RE(ch[ah+2*l1]) = RE(c2) + IM(c3);
  197.                 IM(ch[ah+2*l1]) = IM(c2) - RE(c3);
  198.             }
  199.         } else {
  200.             for (k = 0; k < l1; k++)
  201.             {
  202.                 ac = 3*k+1;
  203.                 ah = k;
  205.                 RE(t2) = RE(cc[ac]) + RE(cc[ac+1]);
  206.                 IM(t2) = IM(cc[ac]) + IM(cc[ac+1]);
  207.                 RE(c2) = RE(cc[ac-1]) + MUL_F(RE(t2),taur);
  208.                 IM(c2) = IM(cc[ac-1]) + MUL_F(IM(t2),taur);
  210.                 RE(ch[ah]) = RE(cc[ac-1]) + RE(t2);
  211.                 IM(ch[ah]) = IM(cc[ac-1]) + IM(t2);
  213.                 RE(c3) = MUL_F((RE(cc[ac]) - RE(cc[ac+1])), taui);
  214.                 IM(c3) = MUL_F((IM(cc[ac]) - IM(cc[ac+1])), taui);
  216.                 RE(ch[ah+l1]) = RE(c2) + IM(c3);
  217.                 IM(ch[ah+l1]) = IM(c2) - RE(c3);
  218.                 RE(ch[ah+2*l1]) = RE(c2) - IM(c3);
  219.                 IM(ch[ah+2*l1]) = IM(c2) + RE(c3);
  220.             }
  221.         }
  222.     } else {
  223.         if (isign == 1)
  224.         {
  225.             for (k = 0; k < l1; k++)
  226.             {
  227.                 for (i = 0; i < ido; i++)
  228.                 {
  229.                     ac = i + (3*k+1)*ido;
  230.                     ah = i + k * ido;
  232.                     RE(t2) = RE(cc[ac]) + RE(cc[ac+ido]);
  233.                     RE(c2) = RE(cc[ac-ido]) + MUL_F(RE(t2),taur);
  234.                     IM(t2) = IM(cc[ac]) + IM(cc[ac+ido]);
  235.                     IM(c2) = IM(cc[ac-ido]) + MUL_F(IM(t2),taur);
  237.                     RE(ch[ah]) = RE(cc[ac-ido]) + RE(t2);
  238.                     IM(ch[ah]) = IM(cc[ac-ido]) + IM(t2);
  240.                     RE(c3) = MUL_F((RE(cc[ac]) - RE(cc[ac+ido])), taui);
  241.                     IM(c3) = MUL_F((IM(cc[ac]) - IM(cc[ac+ido])), taui);
  243.                     RE(d2) = RE(c2) - IM(c3);
  244.                     IM(d3) = IM(c2) - RE(c3);
  245.                     RE(d3) = RE(c2) + IM(c3);
  246.                     IM(d2) = IM(c2) + RE(c3);
  248. #if 1
  249.                     ComplexMult(&IM(ch[ah+l1*ido]), &RE(ch[ah+l1*ido]),
  250.                         IM(d2), RE(d2), RE(wa1[i]), IM(wa1[i]));
  251.                     ComplexMult(&IM(ch[ah+2*l1*ido]), &RE(ch[ah+2*l1*ido]),
  252.                         IM(d3), RE(d3), RE(wa2[i]), IM(wa2[i]));
  253. #else
  254.                     ComplexMult(&RE(ch[ah+l1*ido]), &IM(ch[ah+l1*ido]),
  255.                         RE(d2), IM(d2), RE(wa1[i]), IM(wa1[i]));
  256.                     ComplexMult(&RE(ch[ah+2*l1*ido]), &IM(ch[ah+2*l1*ido]),
  257.                         RE(d3), IM(d3), RE(wa2[i]), IM(wa2[i]));
  258. #endif
  259.                 }
  260.             }
  261.         } else {
  262.             for (k = 0; k < l1; k++)
  263.             {
  264.                 for (i = 0; i < ido; i++)
  265.                 {
  266.                     ac = i + (3*k+1)*ido;
  267.                     ah = i + k * ido;
  269.                     RE(t2) = RE(cc[ac]) + RE(cc[ac+ido]);
  270.                     RE(c2) = RE(cc[ac-ido]) + MUL_F(RE(t2),taur);
  271.                     IM(t2) = IM(cc[ac]) + IM(cc[ac+ido]);
  272.                     IM(c2) = IM(cc[ac-ido]) + MUL_F(IM(t2),taur);
  274.                     RE(ch[ah]) = RE(cc[ac-ido]) + RE(t2);
  275.                     IM(ch[ah]) = IM(cc[ac-ido]) + IM(t2);
  277.                     RE(c3) = MUL_F((RE(cc[ac]) - RE(cc[ac+ido])), taui);
  278.                     IM(c3) = MUL_F((IM(cc[ac]) - IM(cc[ac+ido])), taui);
  280.                     RE(d2) = RE(c2) + IM(c3);
  281.                     IM(d3) = IM(c2) + RE(c3);
  282.                     RE(d3) = RE(c2) - IM(c3);
  283.                     IM(d2) = IM(c2) - RE(c3);
  285. #if 1
  286.                     ComplexMult(&RE(ch[ah+l1*ido]), &IM(ch[ah+l1*ido]),
  287.                         RE(d2), IM(d2), RE(wa1[i]), IM(wa1[i]));
  288.                     ComplexMult(&RE(ch[ah+2*l1*ido]), &IM(ch[ah+2*l1*ido]),
  289.                         RE(d3), IM(d3), RE(wa2[i]), IM(wa2[i]));
  290. #else
  291.                     ComplexMult(&IM(ch[ah+l1*ido]), &RE(ch[ah+l1*ido]),
  292.                         IM(d2), RE(d2), RE(wa1[i]), IM(wa1[i]));
  293.                     ComplexMult(&IM(ch[ah+2*l1*ido]), &RE(ch[ah+2*l1*ido]),
  294.                         IM(d3), RE(d3), RE(wa2[i]), IM(wa2[i]));
  295. #endif
  296.                 }
  297.             }
  298.         }
  299.     }
  300. }
  303. static void passf4pos(const uint16_t ido, const uint16_t l1, const complex_t *cc,
  304.                       complex_t *ch, const complex_t *wa1, const complex_t *wa2,
  305.                       const complex_t *wa3)
  306. {
  307.     uint16_t i, k, ac, ah;
  309.     if (ido == 1)
  310.     {
  311.         for (k = 0; k < l1; k++)
  312.         {
  313.             complex_t t1, t2, t3, t4;
  315.             ac = 4*k;
  316.             ah = k;
  318.             RE(t2) = RE(cc[ac])   + RE(cc[ac+2]);
  319.             RE(t1) = RE(cc[ac])   - RE(cc[ac+2]);
  320.             IM(t2) = IM(cc[ac])   + IM(cc[ac+2]);
  321.             IM(t1) = IM(cc[ac])   - IM(cc[ac+2]);
  322.             RE(t3) = RE(cc[ac+1]) + RE(cc[ac+3]);
  323.             IM(t4) = RE(cc[ac+1]) - RE(cc[ac+3]);
  324.             IM(t3) = IM(cc[ac+3]) + IM(cc[ac+1]);
  325.             RE(t4) = IM(cc[ac+3]) - IM(cc[ac+1]);
  327.             RE(ch[ah])      = RE(t2) + RE(t3);
  328.             RE(ch[ah+2*l1]) = RE(t2) - RE(t3);
  330.             IM(ch[ah])      = IM(t2) + IM(t3);
  331.             IM(ch[ah+2*l1]) = IM(t2) - IM(t3);
  333.             RE(ch[ah+l1])   = RE(t1) + RE(t4);
  334.             RE(ch[ah+3*l1]) = RE(t1) - RE(t4);
  336.             IM(ch[ah+l1])   = IM(t1) + IM(t4);
  337.             IM(ch[ah+3*l1]) = IM(t1) - IM(t4);
  338.         }
  339.     } else {
  340.         for (k = 0; k < l1; k++)
  341.         {
  342.             ac = 4*k*ido;
  343.             ah = k*ido;
  345.             for (i = 0; i < ido; i++)
  346.             {
  347.                 complex_t c2, c3, c4, t1, t2, t3, t4;
  349.                 RE(t2) = RE(cc[ac+i]) + RE(cc[ac+i+2*ido]);
  350.                 RE(t1) = RE(cc[ac+i]) - RE(cc[ac+i+2*ido]);
  351.                 IM(t2) = IM(cc[ac+i]) + IM(cc[ac+i+2*ido]);
  352.                 IM(t1) = IM(cc[ac+i]) - IM(cc[ac+i+2*ido]);
  353.                 RE(t3) = RE(cc[ac+i+ido]) + RE(cc[ac+i+3*ido]);
  354.                 IM(t4) = RE(cc[ac+i+ido]) - RE(cc[ac+i+3*ido]);
  355.                 IM(t3) = IM(cc[ac+i+3*ido]) + IM(cc[ac+i+ido]);
  356.                 RE(t4) = IM(cc[ac+i+3*ido]) - IM(cc[ac+i+ido]);
  358.                 RE(c2) = RE(t1) + RE(t4);
  359.                 RE(c4) = RE(t1) - RE(t4);
  361.                 IM(c2) = IM(t1) + IM(t4);
  362.                 IM(c4) = IM(t1) - IM(t4);
  364.                 RE(ch[ah+i]) = RE(t2) + RE(t3);
  365.                 RE(c3)       = RE(t2) - RE(t3);
  367.                 IM(ch[ah+i]) = IM(t2) + IM(t3);
  368.                 IM(c3)       = IM(t2) - IM(t3);
  370. #if 1
  371.                 ComplexMult(&IM(ch[ah+i+l1*ido]), &RE(ch[ah+i+l1*ido]),
  372.                     IM(c2), RE(c2), RE(wa1[i]), IM(wa1[i]));
  373.                 ComplexMult(&IM(ch[ah+i+2*l1*ido]), &RE(ch[ah+i+2*l1*ido]),
  374.                     IM(c3), RE(c3), RE(wa2[i]), IM(wa2[i]));
  375.                 ComplexMult(&IM(ch[ah+i+3*l1*ido]), &RE(ch[ah+i+3*l1*ido]),
  376.                     IM(c4), RE(c4), RE(wa3[i]), IM(wa3[i]));
  377. #else
  378.                 ComplexMult(&RE(ch[ah+i+l1*ido]), &IM(ch[ah+i+l1*ido]),
  379.                     RE(c2), IM(c2), RE(wa1[i]), IM(wa1[i]));
  380.                 ComplexMult(&RE(ch[ah+i+2*l1*ido]), &IM(ch[ah+i+2*l1*ido]),
  381.                     RE(c3), IM(c3), RE(wa2[i]), IM(wa2[i]));
  382.                 ComplexMult(&RE(ch[ah+i+3*l1*ido]), &IM(ch[ah+i+3*l1*ido]),
  383.                     RE(c4), IM(c4), RE(wa3[i]), IM(wa3[i]));
  384. #endif
  385.             }
  386.         }
  387.     }
  388. }
  390. static void passf4neg(const uint16_t ido, const uint16_t l1, const complex_t *cc,
  391.                       complex_t *ch, const complex_t *wa1, const complex_t *wa2,
  392.                       const complex_t *wa3)
  393. {
  394.     uint16_t i, k, ac, ah;
  396.     if (ido == 1)
  397.     {
  398.         for (k = 0; k < l1; k++)
  399.         {
  400.             complex_t t1, t2, t3, t4;
  402.             ac = 4*k;
  403.             ah = k;
  405.             RE(t2) = RE(cc[ac])   + RE(cc[ac+2]);
  406.             RE(t1) = RE(cc[ac])   - RE(cc[ac+2]);
  407.             IM(t2) = IM(cc[ac])   + IM(cc[ac+2]);
  408.             IM(t1) = IM(cc[ac])   - IM(cc[ac+2]);
  409.             RE(t3) = RE(cc[ac+1]) + RE(cc[ac+3]);
  410.             IM(t4) = RE(cc[ac+1]) - RE(cc[ac+3]);
  411.             IM(t3) = IM(cc[ac+3]) + IM(cc[ac+1]);
  412.             RE(t4) = IM(cc[ac+3]) - IM(cc[ac+1]);
  414.             RE(ch[ah])      = RE(t2) + RE(t3);
  415.             RE(ch[ah+2*l1]) = RE(t2) - RE(t3);
  417.             IM(ch[ah])      = IM(t2) + IM(t3);
  418.             IM(ch[ah+2*l1]) = IM(t2) - IM(t3);
  420.             RE(ch[ah+l1])   = RE(t1) - RE(t4);
  421.             RE(ch[ah+3*l1]) = RE(t1) + RE(t4);
  423.             IM(ch[ah+l1])   = IM(t1) - IM(t4);
  424.             IM(ch[ah+3*l1]) = IM(t1) + IM(t4);
  425.         }
  426.     } else {
  427.         for (k = 0; k < l1; k++)
  428.         {
  429.             ac = 4*k*ido;
  430.             ah = k*ido;
  432.             for (i = 0; i < ido; i++)
  433.             {
  434.                 complex_t c2, c3, c4, t1, t2, t3, t4;
  436.                 RE(t2) = RE(cc[ac+i]) + RE(cc[ac+i+2*ido]);
  437.                 RE(t1) = RE(cc[ac+i]) - RE(cc[ac+i+2*ido]);
  438.                 IM(t2) = IM(cc[ac+i]) + IM(cc[ac+i+2*ido]);
  439.                 IM(t1) = IM(cc[ac+i]) - IM(cc[ac+i+2*ido]);
  440.                 RE(t3) = RE(cc[ac+i+ido]) + RE(cc[ac+i+3*ido]);
  441.                 IM(t4) = RE(cc[ac+i+ido]) - RE(cc[ac+i+3*ido]);
  442.                 IM(t3) = IM(cc[ac+i+3*ido]) + IM(cc[ac+i+ido]);
  443.                 RE(t4) = IM(cc[ac+i+3*ido]) - IM(cc[ac+i+ido]);
  445.                 RE(c2) = RE(t1) - RE(t4);
  446.                 RE(c4) = RE(t1) + RE(t4);
  448.                 IM(c2) = IM(t1) - IM(t4);
  449.                 IM(c4) = IM(t1) + IM(t4);
  451.                 RE(ch[ah+i]) = RE(t2) + RE(t3);
  452.                 RE(c3)       = RE(t2) - RE(t3);
  454.                 IM(ch[ah+i]) = IM(t2) + IM(t3);
  455.                 IM(c3)       = IM(t2) - IM(t3);
  457. #if 1
  458.                 ComplexMult(&RE(ch[ah+i+l1*ido]), &IM(ch[ah+i+l1*ido]),
  459.                     RE(c2), IM(c2), RE(wa1[i]), IM(wa1[i]));
  460.                 ComplexMult(&RE(ch[ah+i+2*l1*ido]), &IM(ch[ah+i+2*l1*ido]),
  461.                     RE(c3), IM(c3), RE(wa2[i]), IM(wa2[i]));
  462.                 ComplexMult(&RE(ch[ah+i+3*l1*ido]), &IM(ch[ah+i+3*l1*ido]),
  463.                     RE(c4), IM(c4), RE(wa3[i]), IM(wa3[i]));
  464. #else
  465.                 ComplexMult(&IM(ch[ah+i+l1*ido]), &RE(ch[ah+i+l1*ido]),
  466.                     IM(c2), RE(c2), RE(wa1[i]), IM(wa1[i]));
  467.                 ComplexMult(&IM(ch[ah+i+2*l1*ido]), &RE(ch[ah+i+2*l1*ido]),
  468.                     IM(c3), RE(c3), RE(wa2[i]), IM(wa2[i]));
  469.                 ComplexMult(&IM(ch[ah+i+3*l1*ido]), &RE(ch[ah+i+3*l1*ido]),
  470.                     IM(c4), RE(c4), RE(wa3[i]), IM(wa3[i]));
  471. #endif
  472.             }
  473.         }
  474.     }
  475. }
  477. static void passf5(const uint16_t ido, const uint16_t l1, const complex_t *cc,
  478.                    complex_t *ch, const complex_t *wa1, const complex_t *wa2, const complex_t *wa3,
  479.                    const complex_t *wa4, const int8_t isign)
  480. {
  481.     static real_t tr11 = FRAC_CONST(0.309016994374947);
  482.     static real_t ti11 = FRAC_CONST(0.951056516295154);
  483.     static real_t tr12 = FRAC_CONST(-0.809016994374947);
  484.     static real_t ti12 = FRAC_CONST(0.587785252292473);
  485.     uint16_t i, k, ac, ah;
  486.     complex_t c2, c3, c4, c5, d3, d4, d5, d2, t2, t3, t4, t5;
  488.     if (ido == 1)
  489.     {
  490.         if (isign == 1)
  491.         {
  492.             for (k = 0; k < l1; k++)
  493.             {
  494.                 ac = 5*k + 1;
  495.                 ah = k;
  497.                 RE(t2) = RE(cc[ac]) + RE(cc[ac+3]);
  498.                 IM(t2) = IM(cc[ac]) + IM(cc[ac+3]);
  499.                 RE(t3) = RE(cc[ac+1]) + RE(cc[ac+2]);
  500.                 IM(t3) = IM(cc[ac+1]) + IM(cc[ac+2]);
  501.                 RE(t4) = RE(cc[ac+1]) - RE(cc[ac+2]);
  502.                 IM(t4) = IM(cc[ac+1]) - IM(cc[ac+2]);
  503.                 RE(t5) = RE(cc[ac]) - RE(cc[ac+3]);
  504.                 IM(t5) = IM(cc[ac]) - IM(cc[ac+3]);
  506.                 RE(ch[ah]) = RE(cc[ac-1]) + RE(t2) + RE(t3);
  507.                 IM(ch[ah]) = IM(cc[ac-1]) + IM(t2) + IM(t3);
  509.                 RE(c2) = RE(cc[ac-1]) + MUL_F(RE(t2),tr11) + MUL_F(RE(t3),tr12);
  510.                 IM(c2) = IM(cc[ac-1]) + MUL_F(IM(t2),tr11) + MUL_F(IM(t3),tr12);
  511.                 RE(c3) = RE(cc[ac-1]) + MUL_F(RE(t2),tr12) + MUL_F(RE(t3),tr11);
  512.                 IM(c3) = IM(cc[ac-1]) + MUL_F(IM(t2),tr12) + MUL_F(IM(t3),tr11);
  514.                 ComplexMult(&RE(c5), &RE(c4),
  515.                     ti11, ti12, RE(t5), RE(t4));
  516.                 ComplexMult(&IM(c5), &IM(c4),
  517.                     ti11, ti12, IM(t5), IM(t4));
  519.                 RE(ch[ah+l1]) = RE(c2) - IM(c5);
  520.                 IM(ch[ah+l1]) = IM(c2) + RE(c5);
  521.                 RE(ch[ah+2*l1]) = RE(c3) - IM(c4);
  522.                 IM(ch[ah+2*l1]) = IM(c3) + RE(c4);
  523.                 RE(ch[ah+3*l1]) = RE(c3) + IM(c4);
  524.                 IM(ch[ah+3*l1]) = IM(c3) - RE(c4);
  525.                 RE(ch[ah+4*l1]) = RE(c2) + IM(c5);
  526.                 IM(ch[ah+4*l1]) = IM(c2) - RE(c5);
  527.             }
  528.         } else {
  529.             for (k = 0; k < l1; k++)
  530.             {
  531.                 ac = 5*k + 1;
  532.                 ah = k;
  534.                 RE(t2) = RE(cc[ac]) + RE(cc[ac+3]);
  535.                 IM(t2) = IM(cc[ac]) + IM(cc[ac+3]);
  536.                 RE(t3) = RE(cc[ac+1]) + RE(cc[ac+2]);
  537.                 IM(t3) = IM(cc[ac+1]) + IM(cc[ac+2]);
  538.                 RE(t4) = RE(cc[ac+1]) - RE(cc[ac+2]);
  539.                 IM(t4) = IM(cc[ac+1]) - IM(cc[ac+2]);
  540.                 RE(t5) = RE(cc[ac]) - RE(cc[ac+3]);
  541.                 IM(t5) = IM(cc[ac]) - IM(cc[ac+3]);
  543.                 RE(ch[ah]) = RE(cc[ac-1]) + RE(t2) + RE(t3);
  544.                 IM(ch[ah]) = IM(cc[ac-1]) + IM(t2) + IM(t3);
  546.                 RE(c2) = RE(cc[ac-1]) + MUL_F(RE(t2),tr11) + MUL_F(RE(t3),tr12);
  547.                 IM(c2) = IM(cc[ac-1]) + MUL_F(IM(t2),tr11) + MUL_F(IM(t3),tr12);
  548.                 RE(c3) = RE(cc[ac-1]) + MUL_F(RE(t2),tr12) + MUL_F(RE(t3),tr11);
  549.                 IM(c3) = IM(cc[ac-1]) + MUL_F(IM(t2),tr12) + MUL_F(IM(t3),tr11);
  551.                 ComplexMult(&RE(c4), &RE(c5),
  552.                     ti12, ti11, RE(t5), RE(t4));
  553.                 ComplexMult(&IM(c4), &IM(c5),
  554.                     ti12, ti12, IM(t5), IM(t4));
  556.                 RE(ch[ah+l1]) = RE(c2) + IM(c5);
  557.                 IM(ch[ah+l1]) = IM(c2) - RE(c5);
  558.                 RE(ch[ah+2*l1]) = RE(c3) + IM(c4);
  559.                 IM(ch[ah+2*l1]) = IM(c3) - RE(c4);
  560.                 RE(ch[ah+3*l1]) = RE(c3) - IM(c4);
  561.                 IM(ch[ah+3*l1]) = IM(c3) + RE(c4);
  562.                 RE(ch[ah+4*l1]) = RE(c2) - IM(c5);
  563.                 IM(ch[ah+4*l1]) = IM(c2) + RE(c5);
  564.             }
  565.         }
  566.     } else {
  567.         if (isign == 1)
  568.         {
  569.             for (k = 0; k < l1; k++)
  570.             {
  571.                 for (i = 0; i < ido; i++)
  572.                 {
  573.                     ac = i + (k*5 + 1) * ido;
  574.                     ah = i + k * ido;
  576.                     RE(t2) = RE(cc[ac]) + RE(cc[ac+3*ido]);
  577.                     IM(t2) = IM(cc[ac]) + IM(cc[ac+3*ido]);
  578.                     RE(t3) = RE(cc[ac+ido]) + RE(cc[ac+2*ido]);
  579.                     IM(t3) = IM(cc[ac+ido]) + IM(cc[ac+2*ido]);
  580.                     RE(t4) = RE(cc[ac+ido]) - RE(cc[ac+2*ido]);
  581.                     IM(t4) = IM(cc[ac+ido]) - IM(cc[ac+2*ido]);
  582.                     RE(t5) = RE(cc[ac]) - RE(cc[ac+3*ido]);
  583.                     IM(t5) = IM(cc[ac]) - IM(cc[ac+3*ido]);
  585.                     RE(ch[ah]) = RE(cc[ac-ido]) + RE(t2) + RE(t3);
  586.                     IM(ch[ah]) = IM(cc[ac-ido]) + IM(t2) + IM(t3);
  588.                     RE(c2) = RE(cc[ac-ido]) + MUL_F(RE(t2),tr11) + MUL_F(RE(t3),tr12);
  589.                     IM(c2) = IM(cc[ac-ido]) + MUL_F(IM(t2),tr11) + MUL_F(IM(t3),tr12);
  590.                     RE(c3) = RE(cc[ac-ido]) + MUL_F(RE(t2),tr12) + MUL_F(RE(t3),tr11);
  591.                     IM(c3) = IM(cc[ac-ido]) + MUL_F(IM(t2),tr12) + MUL_F(IM(t3),tr11);
  593.                     ComplexMult(&RE(c5), &RE(c4),
  594.                         ti11, ti12, RE(t5), RE(t4));
  595.                     ComplexMult(&IM(c5), &IM(c4),
  596.                         ti11, ti12, IM(t5), IM(t4));
  598.                     IM(d2) = IM(c2) + RE(c5);
  599.                     IM(d3) = IM(c3) + RE(c4);
  600.                     RE(d4) = RE(c3) + IM(c4);
  601.                     RE(d5) = RE(c2) + IM(c5);
  602.                     RE(d2) = RE(c2) - IM(c5);
  603.                     IM(d5) = IM(c2) - RE(c5);
  604.                     RE(d3) = RE(c3) - IM(c4);
  605.                     IM(d4) = IM(c3) - RE(c4);
  607. #if 1
  608.                     ComplexMult(&IM(ch[ah+l1*ido]), &RE(ch[ah+l1*ido]),
  609.                         IM(d2), RE(d2), RE(wa1[i]), IM(wa1[i]));
  610.                     ComplexMult(&IM(ch[ah+2*l1*ido]), &RE(ch[ah+2*l1*ido]),
  611.                         IM(d3), RE(d3), RE(wa2[i]), IM(wa2[i]));
  612.                     ComplexMult(&IM(ch[ah+3*l1*ido]), &RE(ch[ah+3*l1*ido]),
  613.                         IM(d4), RE(d4), RE(wa3[i]), IM(wa3[i]));
  614.                     ComplexMult(&IM(ch[ah+4*l1*ido]), &RE(ch[ah+4*l1*ido]),
  615.                         IM(d5), RE(d5), RE(wa4[i]), IM(wa4[i]));
  616. #else
  617.                     ComplexMult(&RE(ch[ah+l1*ido]), &IM(ch[ah+l1*ido]),
  618.                         RE(d2), IM(d2), RE(wa1[i]), IM(wa1[i]));
  619.                     ComplexMult(&RE(ch[ah+2*l1*ido]), &IM(ch[ah+2*l1*ido]),
  620.                         RE(d3), IM(d3), RE(wa2[i]), IM(wa2[i]));
  621.                     ComplexMult(&RE(ch[ah+3*l1*ido]), &IM(ch[ah+3*l1*ido]),
  622.                         RE(d4), IM(d4), RE(wa3[i]), IM(wa3[i]));
  623.                     ComplexMult(&RE(ch[ah+4*l1*ido]), &IM(ch[ah+4*l1*ido]),
  624.                         RE(d5), IM(d5), RE(wa4[i]), IM(wa4[i]));
  625. #endif
  626.                 }
  627.             }
  628.         } else {
  629.             for (k = 0; k < l1; k++)
  630.             {
  631.                 for (i = 0; i < ido; i++)
  632.                 {
  633.                     ac = i + (k*5 + 1) * ido;
  634.                     ah = i + k * ido;
  636.                     RE(t2) = RE(cc[ac]) + RE(cc[ac+3*ido]);
  637.                     IM(t2) = IM(cc[ac]) + IM(cc[ac+3*ido]);
  638.                     RE(t3) = RE(cc[ac+ido]) + RE(cc[ac+2*ido]);
  639.                     IM(t3) = IM(cc[ac+ido]) + IM(cc[ac+2*ido]);
  640.                     RE(t4) = RE(cc[ac+ido]) - RE(cc[ac+2*ido]);
  641.                     IM(t4) = IM(cc[ac+ido]) - IM(cc[ac+2*ido]);
  642.                     RE(t5) = RE(cc[ac]) - RE(cc[ac+3*ido]);
  643.                     IM(t5) = IM(cc[ac]) - IM(cc[ac+3*ido]);
  645.                     RE(ch[ah]) = RE(cc[ac-ido]) + RE(t2) + RE(t3);
  646.                     IM(ch[ah]) = IM(cc[ac-ido]) + IM(t2) + IM(t3);
  648.                     RE(c2) = RE(cc[ac-ido]) + MUL_F(RE(t2),tr11) + MUL_F(RE(t3),tr12);
  649.                     IM(c2) = IM(cc[ac-ido]) + MUL_F(IM(t2),tr11) + MUL_F(IM(t3),tr12);
  650.                     RE(c3) = RE(cc[ac-ido]) + MUL_F(RE(t2),tr12) + MUL_F(RE(t3),tr11);
  651.                     IM(c3) = IM(cc[ac-ido]) + MUL_F(IM(t2),tr12) + MUL_F(IM(t3),tr11);
  653.                     ComplexMult(&RE(c4), &RE(c5),
  654.                         ti12, ti11, RE(t5), RE(t4));
  655.                     ComplexMult(&IM(c4), &IM(c5),
  656.                         ti12, ti12, IM(t5), IM(t4));
  658.                     IM(d2) = IM(c2) - RE(c5);
  659.                     IM(d3) = IM(c3) - RE(c4);
  660.                     RE(d4) = RE(c3) - IM(c4);
  661.                     RE(d5) = RE(c2) - IM(c5);
  662.                     RE(d2) = RE(c2) + IM(c5);
  663.                     IM(d5) = IM(c2) + RE(c5);
  664.                     RE(d3) = RE(c3) + IM(c4);
  665.                     IM(d4) = IM(c3) + RE(c4);
  667. #if 1
  668.                     ComplexMult(&RE(ch[ah+l1*ido]), &IM(ch[ah+l1*ido]),
  669.                         RE(d2), IM(d2), RE(wa1[i]), IM(wa1[i]));
  670.                     ComplexMult(&RE(ch[ah+2*l1*ido]), &IM(ch[ah+2*l1*ido]),
  671.                         RE(d3), IM(d3), RE(wa2[i]), IM(wa2[i]));
  672.                     ComplexMult(&RE(ch[ah+3*l1*ido]), &IM(ch[ah+3*l1*ido]),
  673.                         RE(d4), IM(d4), RE(wa3[i]), IM(wa3[i]));
  674.                     ComplexMult(&RE(ch[ah+4*l1*ido]), &IM(ch[ah+4*l1*ido]),
  675.                         RE(d5), IM(d5), RE(wa4[i]), IM(wa4[i]));
  676. #else
  677.                     ComplexMult(&IM(ch[ah+l1*ido]), &RE(ch[ah+l1*ido]),
  678.                         IM(d2), RE(d2), RE(wa1[i]), IM(wa1[i]));
  679.                     ComplexMult(&IM(ch[ah+2*l1*ido]), &RE(ch[ah+2*l1*ido]),
  680.                         IM(d3), RE(d3), RE(wa2[i]), IM(wa2[i]));
  681.                     ComplexMult(&IM(ch[ah+3*l1*ido]), &RE(ch[ah+3*l1*ido]),
  682.                         IM(d4), RE(d4), RE(wa3[i]), IM(wa3[i]));
  683.                     ComplexMult(&IM(ch[ah+4*l1*ido]), &RE(ch[ah+4*l1*ido]),
  684.                         IM(d5), RE(d5), RE(wa4[i]), IM(wa4[i]));
  685. #endif
  686.                 }
  687.             }
  688.         }
  689.     }
  690. }
  693. /*----------------------------------------------------------------------
  694.    cfftf1, cfftf, cfftb, cffti1, cffti. Complex FFTs.
  695.   ----------------------------------------------------------------------*/
  697. static INLINE void cfftf1pos(uint16_t n, complex_t *c, complex_t *ch,
  698.                              const uint16_t *ifac, const complex_t *wa,
  699.                              const int8_t isign)
  700. {
  701.     uint16_t i;
  702.     uint16_t k1, l1, l2;
  703.     uint16_t na, nf, ip, iw, ix2, ix3, ix4, ido, idl1;
  705.     nf = ifac[1];
  706.     na = 0;
  707.     l1 = 1;
  708.     iw = 0;
  710.     for (k1 = 2; k1 <= nf+1; k1++)
  711.     {
  712.         ip = ifac[k1];
  713.         l2 = ip*l1;
  714.         ido = n / l2;
  715.         idl1 = ido*l1;
  717.         switch (ip)
  718.         {
  719.         case 4:
  720.             ix2 = iw + ido;
  721.             ix3 = ix2 + ido;
  723.             if (na == 0)
  724.                 passf4pos((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)c, ch, &wa[iw], &wa[ix2], &wa[ix3]);
  725.             else
  726.                 passf4pos((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)ch, c, &wa[iw], &wa[ix2], &wa[ix3]);
  728.             na = 1 - na;
  729.             break;
  730.         case 2:
  731.             if (na == 0)
  732.                 passf2pos((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)c, ch, &wa[iw]);
  733.             else
  734.                 passf2pos((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)ch, c, &wa[iw]);
  736.             na = 1 - na;
  737.             break;
  738.         case 3:
  739.             ix2 = iw + ido;
  741.             if (na == 0)
  742.                 passf3((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)c, ch, &wa[iw], &wa[ix2], isign);
  743.             else
  744.                 passf3((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)ch, c, &wa[iw], &wa[ix2], isign);
  746.             na = 1 - na;
  747.             break;
  748.         case 5:
  749.             ix2 = iw + ido;
  750.             ix3 = ix2 + ido;
  751.             ix4 = ix3 + ido;
  753.             if (na == 0)
  754.                 passf5((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)c, ch, &wa[iw], &wa[ix2], &wa[ix3], &wa[ix4], isign);
  755.             else
  756.                 passf5((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)ch, c, &wa[iw], &wa[ix2], &wa[ix3], &wa[ix4], isign);
  758.             na = 1 - na;
  759.             break;
  760.         }
  762.         l1 = l2;
  763.         iw += (ip-1) * ido;
  764.     }
  766.     if (na == 0)
  767.         return;
  769.     for (i = 0; i < n; i++)
  770.     {
  771.         RE(c[i]) = RE(ch[i]);
  772.         IM(c[i]) = IM(ch[i]);
  773.     }
  774. }
  776. static INLINE void cfftf1neg(uint16_t n, complex_t *c, complex_t *ch,
  777.                              const uint16_t *ifac, const complex_t *wa,
  778.                              const int8_t isign)
  779. {
  780.     uint16_t i;
  781.     uint16_t k1, l1, l2;
  782.     uint16_t na, nf, ip, iw, ix2, ix3, ix4, ido, idl1;
  784.     nf = ifac[1];
  785.     na = 0;
  786.     l1 = 1;
  787.     iw = 0;
  789.     for (k1 = 2; k1 <= nf+1; k1++)
  790.     {
  791.         ip = ifac[k1];
  792.         l2 = ip*l1;
  793.         ido = n / l2;
  794.         idl1 = ido*l1;
  796.         switch (ip)
  797.         {
  798.         case 4:
  799.             ix2 = iw + ido;
  800.             ix3 = ix2 + ido;
  802.             if (na == 0)
  803.                 passf4neg((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)c, ch, &wa[iw], &wa[ix2], &wa[ix3]);
  804.             else
  805.                 passf4neg((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)ch, c, &wa[iw], &wa[ix2], &wa[ix3]);
  807.             na = 1 - na;
  808.             break;
  809.         case 2:
  810.             if (na == 0)
  811.                 passf2neg((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)c, ch, &wa[iw]);
  812.             else
  813.                 passf2neg((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)ch, c, &wa[iw]);
  815.             na = 1 - na;
  816.             break;
  817.         case 3:
  818.             ix2 = iw + ido;
  820.             if (na == 0)
  821.                 passf3((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)c, ch, &wa[iw], &wa[ix2], isign);
  822.             else
  823.                 passf3((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)ch, c, &wa[iw], &wa[ix2], isign);
  825.             na = 1 - na;
  826.             break;
  827.         case 5:
  828.             ix2 = iw + ido;
  829.             ix3 = ix2 + ido;
  830.             ix4 = ix3 + ido;
  832.             if (na == 0)
  833.                 passf5((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)c, ch, &wa[iw], &wa[ix2], &wa[ix3], &wa[ix4], isign);
  834.             else
  835.                 passf5((const uint16_t)ido, (const uint16_t)l1, (const complex_t*)ch, c, &wa[iw], &wa[ix2], &wa[ix3], &wa[ix4], isign);
  837.             na = 1 - na;
  838.             break;
  839.         }
  841.         l1 = l2;
  842.         iw += (ip-1) * ido;
  843.     }
  845.     if (na == 0)
  846.         return;
  848.     for (i = 0; i < n; i++)
  849.     {
  850.         RE(c[i]) = RE(ch[i]);
  851.         IM(c[i]) = IM(ch[i]);
  852.     }
  853. }
  855. void cfftf(cfft_info *cfft, complex_t *c)
  856. {
  857.     cfftf1neg(cfft->n, c, cfft->work, (const uint16_t*)cfft->ifac, (const complex_t*)cfft->tab, -1);
  858. }
  860. void cfftb(cfft_info *cfft, complex_t *c)
  861. {
  862.     cfftf1pos(cfft->n, c, cfft->work, (const uint16_t*)cfft->ifac, (const complex_t*)cfft->tab, +1);
  863. }
  865. static void cffti1(uint16_t n, complex_t *wa, uint16_t *ifac)
  866. {
  867.     static uint16_t ntryh[4] = {3, 4, 2, 5};
  868. #ifndef FIXED_POINT
  869.     real_t arg, argh, argld, fi;
  870.     uint16_t ido, ipm;
  871.     uint16_t i1, k1, l1, l2;
  872.     uint16_t ld, ii, ip;
  873. #endif
  874.     uint16_t ntry = 0, i, j;
  875.     uint16_t ib;
  876.     uint16_t nf, nl, nq, nr;
  878.     nl = n;
  879.     nf = 0;
  880.     j = 0;
  882. startloop:
  883.     j++;
  885.     if (j <= 4)
  886.         ntry = ntryh[j-1];
  887.     else
  888.         ntry += 2;
  890.     do
  891.     {
  892.         nq = nl / ntry;
  893.         nr = nl - ntry*nq;
  895.         if (nr != 0)
  896.             goto startloop;
  898.         nf++;
  899.         ifac[nf+1] = ntry;
  900.         nl = nq;
  902.         if (ntry == 2 && nf != 1)
  903.         {
  904.             for (i = 2; i <= nf; i++)
  905.             {
  906.                 ib = nf - i + 2;
  907.                 ifac[ib+1] = ifac[ib];
  908.             }
  909.             ifac[2] = 2;
  910.         }
  911.     } while (nl != 1);
  913.     ifac[0] = n;
  914.     ifac[1] = nf;
  916. #ifndef FIXED_POINT
  917.     argh = (real_t)2.0*(real_t)M_PI / (real_t)n;
  918.     i = 0;
  919.     l1 = 1;
  921.     for (k1 = 1; k1 <= nf; k1++)
  922.     {
  923.         ip = ifac[k1+1];
  924.         ld = 0;
  925.         l2 = l1*ip;
  926.         ido = n / l2;
  927.         ipm = ip - 1;
  929.         for (j = 0; j < ipm; j++)
  930.         {
  931.             i1 = i;
  932.             RE(wa[i]) = 1.0;
  933.             IM(wa[i]) = 0.0;
  934.             ld += l1;
  935.             fi = 0;
  936.             argld = ld*argh;
  938.             for (ii = 0; ii < ido; ii++)
  939.             {
  940.                 i++;
  941.                 fi++;
  942.                 arg = fi * argld;
  943.                 RE(wa[i]) = (real_t)cos(arg);
  944. #if 1
  945.                 IM(wa[i]) = (real_t)sin(arg);
  946. #else
  947.                 IM(wa[i]) = (real_t)-sin(arg);
  948. #endif
  949.             }
  951.             if (ip > 5)
  952.             {
  953.                 RE(wa[i1]) = RE(wa[i]);
  954.                 IM(wa[i1]) = IM(wa[i]);
  955.             }
  956.         }
  957.         l1 = l2;
  958.     }
  959. #endif
  960. }
  962. cfft_info *cffti(uint16_t n)
  963. {
  964.     cfft_info *cfft = (cfft_info*)faad_malloc(sizeof(cfft_info));
  966.     cfft->n = n;
  967.     cfft->work = (complex_t*)faad_malloc(n*sizeof(complex_t));
  969. #ifndef FIXED_POINT
  970.     cfft->tab = (complex_t*)faad_malloc(n*sizeof(complex_t));
  972.     cffti1(n, cfft->tab, cfft->ifac);
  973. #else
  974.     cffti1(n, NULL, cfft->ifac);
  976.     switch (n)
  977.     {
  978.     case 64: cfft->tab = (complex_t*)cfft_tab_64; break;
  979.     case 512: cfft->tab = (complex_t*)cfft_tab_512; break;
  980. #ifdef LD_DEC
  981.     case 256: cfft->tab = (complex_t*)cfft_tab_256; break;
  982. #endif
  984. #ifdef ALLOW_SMALL_FRAMELENGTH
  985.     case 60: cfft->tab = (complex_t*)cfft_tab_60; break;
  986.     case 480: cfft->tab = (complex_t*)cfft_tab_480; break;
  987. #ifdef LD_DEC
  988.     case 240: cfft->tab = (complex_t*)cfft_tab_240; break;
  989. #endif
  990. #endif
  991.     case 128: cfft->tab = (complex_t*)cfft_tab_128; break;
  992.     }
  993. #endif
  995.     return cfft;
  996. }
  998. void cfftu(cfft_info *cfft)
  999. {
  1000.     if (cfft->work) faad_free(cfft->work);
  1001. #ifndef FIXED_POINT
  1002.     if (cfft->tab) faad_free(cfft->tab);
  1003. #endif
  1005.     if (cfft) faad_free(cfft);
  1006. }