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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 语音压缩 > 查看源码
math_lib.c
资源名称：melp.rar　[点击查看]
上传用户：csczyc
上传日期：2021-02-19
资源大小：1051k
文件大小：28k
源码类别：

语音压缩

开发平台：

C/C++

math_lib.c：源码内容
  1. #include <stdio.h>
  2. #include <math.h>
  3. #include "spbstd.h"
  4. #include "mathhalf.h"
  5. #include "mathdp31.h"
  6. #include "wmops.h"
  7. #include "math_lib.h"
  8. #include "constant.h"
  10. //extern int complexity;
  11. extern int saturation;
  13. Shortword DEBUG;
  15. /***************************************************************************
  16.  *
  17.  *   FUNCTION NAME: L_divider2
  18.  *
  19.  *   PURPOSE:
  20.  *
  21.  *     Divide numer by denom.  If numer is bigger than denom, a warning
  22.  *     is given and a zero is returned.
  23.  *
  24.  *
  25.  *   INPUTS:
  26.  *
  27.  *     numer
  28.  *                     32 bit long signed integer (Longword).
  29.  *     denom
  30.  *                     32 bit long signed integer (Longword).
  31.  *     numer_shift
  32.  *                     16 bit short signed integer (Shortword) represents
  33.  *                     number of right shifts for numer.
  34.  *     denom_shift
  35.  *                     16 bit short signed integer (Shortword) represents
  36.  *                     number of left shifts for denom.
  37.  *
  38.  *   OUTPUTS:
  39.  *
  40.  *     none
  41.  *
  42.  *   RETURN VALUE:
  43.  *
  44.  *     result
  45.  *                     16 bit short signed integer (Shortword).
  46.  *
  47.  *************************************************************************/
  48. Shortword L_divider2(Longword numer, Longword denom, Shortword numer_shift, 
  49.      Shortword denom_shift)
  50. {
  51.   
  52.   Shortword result;
  53.   Shortword sign=0;
  54.   Shortword short_shift=0;
  55.   Longword L_temp;
  56.   
  57.   Shortword temp1,temp2;
  58.   Longword L_temp1;
  59.   
  60.   DEBUG = 1;
  62.   if (denom==0&& DEBUG )
  63.     printf("L_divider2: division by 0n");
  64.   
  65.   /* increment complexity for if statement */
  66. //  compare_zero();mark del
  67.   if (numer<0) {
  68.     sign = !sign;
  69. //        data_move();mark del
  70.   }
  71.   /* increment complexity for if statement */
  72. //  compare_zero();mark del
  73.   if (denom<0) {
  74.     sign = !sign;  
  75. //      data_move();mark del
  76.   }
  78. /*   L_temp = L_shl(denom, denom_shift); */
  79. /*   denom = L_abs(L_temp);              */
  80. /*  //     L_data_move();mark del        */
  81. /*   L_temp = L_shr(numer, numer_shift); */
  82. /*   numer = L_abs(L_temp);              */
  83. /*  //    L_data_move();mark del         */
  84.   L_temp = _sshvl(denom, denom_shift);
  85.   denom = _abs(L_temp);
  86.  //     L_data_move();mark del
  87.   L_temp = _sshvr(numer, numer_shift);
  88.   numer = _abs(L_temp); 
  89.  //    L_data_move();mark del
  90.   
  91.   while (denom>(Longword)SW_MAX)
  92.     {
  93.       /* increment complexity for while statement */
  94. //      L_compare_nonzero();mark del
  96.       /* denom = L_shr(denom,1);  */
  97.   denom = _sshvr(denom,1); 
  98.  //        L_data_move();mark del
  99.       /* short_shift = add(short_shift,1); */
  100.   L_temp1 = _sadd2((Longword)short_shift,1);
  101.   short_shift = (Shortword) (0x0000ffffL & L_temp1);
  102.  //         data_move();mark del
  103.     }
  104.  /*  numer = L_shr(numer, short_shift);  */
  105.      numer = _sshvr(numer, short_shift); 
  106.   //   L_data_move();mark del
  108.   if (numer > denom && DEBUG)
  109.       printf("warning: L_divide2>1: numer %.1f times denomn",
  110.      (float)numer / (float)denom);
  111.   
  112.  /*  result = divide_s(extract_l(numer),extract_l(denom)); */
  113.     temp1 = (Shortword) (0x0000ffffL & numer);
  114. temp2 = (Shortword) (0x0000ffffL & denom);
  115. result = divide_s(temp1,temp2);
  116.   
  117.   /* increment complexity for if statement */
  118. //  compare_zero();mark del
  119.   if (sign) {
  120.     result = negate(result); 
  121. //       data_move();mark del
  122.   }
  124.   return(result);
  125. } /* L_divider2 */
  128. /***************************************************************************
  129.  *
  130.  *   FUNCTION NAME: log10_fxp
  131.  *
  132.  *   PURPOSE:
  133.  *
  134.  *     Compute the logarithm to the base 10 of x.
  135.  *
  136.  *
  137.  *   INPUTS:
  138.  *
  139.  *     x
  140.  *                     16 bit short signed integer (Shortword).
  141.  *     Q
  142.  *                     16 bit short signed integer (Shortword) represents
  143.  *                     Q value of x.
  144.  *
  145.  *   OUTPUTS:
  146.  *
  147.  *     none
  148.  *
  149.  *   RETURN VALUE:
  150.  *
  151.  *     y
  152.  *                     16 bit short signed integer (Shortword) in Q12.
  153.  *
  154.  *************************************************************************/
  155. Shortword log10_fxp(Shortword x, Shortword Q)
  156. {
  157.   /* table is Q13 */
  158.   static Shortword table[256]=
  159.   {
  160.     0, 2466, 3908, 4932, 5725, 6374, 6923, 7398, 7817, 8192, 
  161.     8531, 8840, 9125, 9389, 9634, 9864, 10079, 10283, 10475, 10658, 
  162.     10831, 10997, 11155, 11306, 11451, 11591, 11725, 11855, 11979, 12100, 
  163.     12217, 12330, 12439, 12545, 12649, 12749, 12846, 12941, 13034, 13124, 
  164.     13211, 13297, 13381, 13463, 13543, 13621, 13697, 13772, 13846, 13917, 
  165.     13988, 14057, 14125, 14191, 14257, 14321, 14384, 14446, 14506, 14566, 
  166.     14625, 14683, 14740, 14796, 14851, 14905, 14959, 15011, 15063, 15115, 
  167.     15165, 15215, 15264, 15312, 15360, 15407, 15454, 15500, 15545, 15590, 
  168.     15634, 15677, 15721, 15763, 15805, 15847, 15888, 15929, 15969, 16009, 
  169.     16048, 16087, 16125, 16163, 16201, 16238, 16275, 16312, 16348, 16384, 
  170.     16419, 16454, 16489, 16523, 16557, 16591, 16624, 16657, 16690, 16723, 
  171.     16755, 16787, 16818, 16850, 16881, 16912, 16942, 16972, 17002, 17032, 
  172.     17062, 17091, 17120, 17149, 17177, 17206, 17234, 17262, 17289, 17317, 
  173.     17344, 17371, 17398, 17425, 17451, 17477, 17504, 17529, 17555, 17581, 
  174.     17606, 17631, 17656, 17681, 17705, 17730, 17754, 17778, 17802, 17826, 
  175.     17850, 17873, 17896, 17920, 17943, 17966, 17988, 18011, 18033, 18056, 
  176.     18078, 18100, 18122, 18144, 18165, 18187, 18208, 18229, 18250, 18271, 
  177.     18292, 18313, 18334, 18354, 18374, 18395, 18415, 18435, 18455, 18475, 
  178.     18494, 18514, 18533, 18553, 18572, 18591, 18610, 18629, 18648, 18667, 
  179.     18686, 18704, 18723, 18741, 18759, 18778, 18796, 18814, 18832, 18850, 
  180.     18867, 18885, 18903, 18920, 18937, 18955, 18972, 18989, 19006, 19023, 
  181.     19040, 19057, 19074, 19090, 19107, 19123, 19140, 19156, 19172, 19189, 
  182.     19205, 19221, 19237, 19253, 19269, 19284, 19300, 19316, 19331, 19347, 
  183.     19362, 19378, 19393, 19408, 19423, 19438, 19453, 19468, 19483, 19498, 
  184.     19513, 19528, 19542, 19557, 19572, 19586, 19600, 19615, 19629, 19643, 
  185.     19658, 19672, 19686, 19700, 19714, 19728 };
  186.   
  187.     Shortword y, interp_factor, interp_component;
  188.     Shortword index1, index2;
  189.     Shortword shift;
  190.     Shortword temp1;
  191.     Longword L_temp;
  192. Longword L_temp1,L_temp2,L_y;
  193.     
  194.     shift = sub(7,Q);
  195.     //        data_move();mark del
  197.     /* increment complexity for if statement */
  198.  //   compare_zero();mark del
  199.     if (!x)
  200.       {
  201. return(-SW_MAX);
  202.       }
  204.     while( !(index2=shr(x,7)) && x)
  205.       {
  206. /* increment complexity for while statement */
  207. // data_move();    compare_zero();mark del
  209. /* x=shl(x,1);  */
  210. x = (Shortword)(_sshl((Longword)x,1));
  211. //    data_move();mark del
  212. shift = sub(shift,1);  
  213. //   data_move();mark del
  214.       }
  215.     index1 = sub(index2,1);  
  216.  //       data_move();mark del
  217.     
  218.     /* interpolation */
  219.     interp_factor = shl_a((Shortword)(x&127),8);  
  220.     // logic();mark del
  221.     temp1 = sub(table[index2],table[index1]);
  222.    /*  interp_component = mult(temp1,interp_factor);  */
  223.      L_temp1 = _smpy(temp1,interp_factor);                            
  224.      interp_component = (Shortword) (0x0000ffffL & (L_temp1 >> 16));     
  225.     // data_move();mark del
  227.     /* return a Q12 */
  228.    /*  L_temp = L_mult(table[1],shift);      */
  229. /*     L_temp = L_shr(L_temp,2);             */
  230. /*     temp1 = shr(table[index1],1);         */
  231. /*     temp1 = add(temp1,extract_l(L_temp)); */
  232. /*     temp2 = shr(interp_component,1);      */
  233. /*     y = add(temp1,temp2);                 */ 
  234.        L_temp = _smpy(table[1],shift);
  235.        L_temp = _sshvr(L_temp,2);
  236.        L_temp1 = (Longword)(table[index1]);
  237.        L_temp1 =  _shr2(L_temp1,1);  
  238.    L_temp1 = _sadd2(L_temp1,L_temp);
  239.    L_temp2 = (Longword)interp_component;
  240.    L_temp2 = _shr2(L_temp2,1);
  241.    L_y = _sadd2(L_temp1,L_temp2);
  242.    y = (Shortword) (0x0000ffffL & L_y);
  243.     // data_move();mark del
  245.     return(y);
  246. } /* log10_fxp */
  249. /***************************************************************************
  250.  *
  251.  *   FUNCTION NAME: L_log10_fxp
  252.  *
  253.  *   PURPOSE:
  254.  *
  255.  *     Compute the logarithm to the base 10 of x.
  256.  *
  257.  *
  258.  *   INPUTS:
  259.  *
  260.  *     x
  261.  *                     32 bit long signed integer (Longword).
  262.  *     Q
  263.  *                     16 bit short signed integer (Shortword) represents
  264.  *                     Q value of x.
  265.  *
  266.  *   OUTPUTS:
  267.  *
  268.  *     none
  269.  *
  270.  *   RETURN VALUE:
  271.  *
  272.  *     y
  273.  *                     16 bit short signed integer (Shortword) in Q11.
  274.  *
  275.  *************************************************************************/
  276. Shortword L_log10_fxp(Longword x, Shortword Q)
  277. {
  278.   /* table is Q13 */
  279.   static Shortword table[256]=
  280.   {
  281.     0, 2466, 3908, 4932, 5725, 6374, 6923, 7398, 7817, 8192, 
  282.     8531, 8840, 9125, 9389, 9634, 9864, 10079, 10283, 10475, 10658, 
  283.     10831, 10997, 11155, 11306, 11451, 11591, 11725, 11855, 11979, 12100, 
  284.     12217, 12330, 12439, 12545, 12649, 12749, 12846, 12941, 13034, 13124, 
  285.     13211, 13297, 13381, 13463, 13543, 13621, 13697, 13772, 13846, 13917, 
  286.     13988, 14057, 14125, 14191, 14257, 14321, 14384, 14446, 14506, 14566, 
  287.     14625, 14683, 14740, 14796, 14851, 14905, 14959, 15011, 15063, 15115, 
  288.     15165, 15215, 15264, 15312, 15360, 15407, 15454, 15500, 15545, 15590, 
  289.     15634, 15677, 15721, 15763, 15805, 15847, 15888, 15929, 15969, 16009, 
  290.     16048, 16087, 16125, 16163, 16201, 16238, 16275, 16312, 16348, 16384, 
  291.     16419, 16454, 16489, 16523, 16557, 16591, 16624, 16657, 16690, 16723, 
  292.     16755, 16787, 16818, 16850, 16881, 16912, 16942, 16972, 17002, 17032, 
  293.     17062, 17091, 17120, 17149, 17177, 17206, 17234, 17262, 17289, 17317, 
  294.     17344, 17371, 17398, 17425, 17451, 17477, 17504, 17529, 17555, 17581, 
  295.     17606, 17631, 17656, 17681, 17705, 17730, 17754, 17778, 17802, 17826, 
  296.     17850, 17873, 17896, 17920, 17943, 17966, 17988, 18011, 18033, 18056, 
  297.     18078, 18100, 18122, 18144, 18165, 18187, 18208, 18229, 18250, 18271, 
  298.     18292, 18313, 18334, 18354, 18374, 18395, 18415, 18435, 18455, 18475, 
  299.     18494, 18514, 18533, 18553, 18572, 18591, 18610, 18629, 18648, 18667, 
  300.     18686, 18704, 18723, 18741, 18759, 18778, 18796, 18814, 18832, 18850, 
  301.     18867, 18885, 18903, 18920, 18937, 18955, 18972, 18989, 19006, 19023, 
  302.     19040, 19057, 19074, 19090, 19107, 19123, 19140, 19156, 19172, 19189, 
  303.     19205, 19221, 19237, 19253, 19269, 19284, 19300, 19316, 19331, 19347, 
  304.     19362, 19378, 19393, 19408, 19423, 19438, 19453, 19468, 19483, 19498, 
  305.     19513, 19528, 19542, 19557, 19572, 19586, 19600, 19615, 19629, 19643, 
  306.     19658, 19672, 19686, 19700, 19714, 19728 };
  307.   
  308.     Shortword y, interp_component;
  309.     Longword interp_factor;    
  310.     Shortword index1, index2;
  311.     Shortword shift;
  312.     Shortword temp1;
  313.     Longword L_temp;
  315. Longword L_temp1,L_y;
  317.     
  318.     
  319.     shift = sub(23,Q);
  320.     //        data_move();mark del
  322.     /* increment complexity for if statement */
  323.     //compare_zero();mark del
  324.     if (!x)
  325.       {
  326. return((Shortword)-SW_MAX);
  327.       }
  328.     
  330.     while( !(index2=extract_l(_sshvr(x,23))) && x)
  331.       {
  332. /* increment complexity for while statement */
  333. // compare_zero();    data_move();mark del
  335. /* x=L_shl(x,1); */
  336. x = _sshl(x,1);
  337. shift = sub(shift,1);//    data_move();mark del
  338.       }
  339.     index1 = sub(index2,1);//    data_move();mark del
  340.     
  341.     
  342.     /* interpolation */
  343.     /* interp_factor = L_shl(x&(Longword)0x7fffff, 8);//    L_logic();mark del */
  344. /*     temp1 = sub(table[index2],table[index1]);                               */
  345. /*     interp_component = extract_h(L_mpy_ls(interp_factor,temp1));            */
  346.     interp_factor = _sshl(x&(Longword)0x7fffff, 8);//    L_logic();mark del
  347.     temp1 = sub(table[index2],table[index1]);
  348. L_temp1 = L_mpy_ls(interp_factor,temp1);
  349.     interp_component = (Shortword) (0x0000ffffL & (L_temp1 >> 16));
  352.     /* return a Q11 */
  353.    /*  L_temp = L_mult(table[1],shift);        log10(2^shift) */ 
  354. /*     L_temp = L_shr(L_temp,3);                                   */
  355. /*     temp1 = shr(table[index1],2);                               */
  356. /*     temp1 = add(temp1,extract_l(L_temp));                       */
  357. /*     temp2 = shr(interp_component,2);                            */
  358. /*     y = add(temp1,temp2); //  data_move();mark del              */
  359.     L_temp = _smpy(table[1],shift);       /* log10(2^shift) */
  360.     L_temp = _sshvr(L_temp,3);
  361. L_temp1 = _shr2((Longword)(table[index1]),2);
  362.     L_temp1 = _sadd2(L_temp1,L_temp);
  363.     L_temp = _shr2((Longword)interp_component,2);
  364.     L_y = _sadd2(L_temp1,L_temp); //  data_move();mark del
  365. y = (Shortword) (0x0000ffffL & L_y);
  366.     
  367.       
  368.     return(y);
  369. } /* L_log10_fxp */
  372. /***************************************************************************
  373.  *
  374.  *   FUNCTION NAME: pow10_fxp
  375.  *
  376.  *   PURPOSE:
  377.  *
  378.  *     Compute 10 raised to the power x.
  379.  *
  380.  *
  381.  *   INPUTS:
  382.  *
  383.  *     x
  384.  *                     16 bit short signed integer (Shortword) in Q12.
  385.  *     Q
  386.  *                     16 bit short signed integer (Shortword) represents
  387.  *                     required Q value of returned result.
  388.  *
  389.  *   OUTPUTS:
  390.  *
  391.  *     none
  392.  *
  393.  *   RETURN VALUE:
  394.  *
  395.  *     y
  396.  *                     16 bit short signed integer (Shortword).
  397.  *
  398.  *************************************************************************/
  399. Shortword pow10_fxp(Shortword x, Shortword Q)
  400. {
  401.   /* table in Q11 */
  402.   Shortword table[257]=
  403.   {
  404.     2048, 2066, 2085, 2104, 2123, 2142, 2161, 2181, 2200, 2220, 
  405.     2240, 2260, 2281, 2302, 2322, 2343, 2364, 2386, 2407, 2429, 
  406.     2451, 2473, 2496, 2518, 2541, 2564, 2587, 2610, 2634, 2658, 
  407.     2682, 2706, 2731, 2755, 2780, 2805, 2831, 2856, 2882, 2908, 
  408.     2934, 2961, 2988, 3015, 3042, 3069, 3097, 3125, 3153, 3182, 
  409.     3211, 3240, 3269, 3298, 3328, 3358, 3389, 3419, 3450, 3481, 
  410.     3513, 3544, 3576, 3609, 3641, 3674, 3708, 3741, 3775, 3809, 
  411.     3843, 3878, 3913, 3948, 3984, 4020, 4056, 4093, 4130, 4167, 
  412.     4205, 4243, 4281, 4320, 4359, 4399, 4438, 4478, 4519, 4560, 
  413.     4601, 4643, 4684, 4727, 4769, 4813, 4856, 4900, 4944, 4989, 
  414.     5034, 5079, 5125, 5172, 5218, 5266, 5313, 5361, 5410, 5458, 
  415.     5508, 5558, 5608, 5658, 5710, 5761, 5813, 5866, 5919, 5972, 
  416.     6026, 6081, 6136, 6191, 6247, 6303, 6360, 6418, 6476, 6534, 
  417.     6593, 6653, 6713, 6774, 6835, 6897, 6959, 7022, 7085, 7149, 
  418.     7214, 7279, 7345, 7411, 7478, 7546, 7614, 7683, 7752, 7822, 
  419.     7893, 7964, 8036, 8109, 8182, 8256, 8331, 8406, 8482, 8559, 
  420.     8636, 8714, 8793, 8872, 8952, 9033, 9115, 9197, 9280, 9364, 
  421.     9449, 9534, 9620, 9707, 9795, 9883, 9973, 10063, 10154, 10245, 
  422.     10338, 10431, 10526, 10621, 10717, 10813, 10911, 11010, 11109, 11210, 
  423.     11311, 11413, 11516, 11620, 11725, 11831, 11938, 12046, 12155, 12265, 
  424.     12375, 12487, 12600, 12714, 12829, 12945, 13062, 13180, 13299, 13419, 
  425.     13540, 13663, 13786, 13911, 14036, 14163, 14291, 14420, 14550, 14682, 
  426.     14815, 14948, 15084, 15220, 15357, 15496, 15636, 15777, 15920, 16064, 
  427.     16209, 16355, 16503, 16652, 16803, 16955, 17108, 17262, 17418, 17576, 
  428.     17734, 17895, 18056, 18220, 18384, 18550, 18718, 18887, 19058, 19230, 
  429.     19404, 19579, 19756, 19934, 20114, 20296, 20480 };
  430.   
  431.   static Shortword tens_table[9]=
  432.   {
  433.     26844, 16777, 20972, 26214, 1, 10, 100, 1000, 10000
  434.   };
  435.   
  436.   static Shortword Q_table[4]=
  437.   {
  438.     28, 24, 21, 18
  439.   };
  440.   
  441.   
  442.   Shortword y, interp_factor, interp_component;
  443.   Shortword index1, index2;
  444.   Shortword ten_multiple;
  445.   Longword L_y;
  446.   Shortword temp1, temp2;
  447.   
  448.   Shortword temp;
  449.   Longword L_temp;
  450.   
  451.  /*  ten_multiple = shr(x,12);  // data_move();mark del */
  452.   L_temp = _shr2((Longword)x,12);
  453.   ten_multiple = (Shortword) (0x0000ffffL & L_temp);
  455.   if (ten_multiple < -4)
  456.     return((Shortword)0);
  457.   else if (ten_multiple > 4) {
  458.     saturation = saturation + 1;
  459.     return((Shortword)SW_MAX);
  460.   }
  461.   
  462.   /* index1 = shr((Shortword)(x&(Shortword)0x0ff0), 4);   // logic();  data_move();mark del */
  463. /*   index2 = add(index1,1); //   data_move();mark del                                      */
  464.   L_temp = _shr2((Longword)(x&(Shortword)0x0ff0),4);
  465.   index1 = (Shortword) (0x0000ffffL & L_temp);   // logic();  data_move();mark del
  466.   L_temp = _sadd2(L_temp,(Longword)1);
  467.   index2 = (Shortword) (0x0000ffffL & L_temp);; //   data_move();mark del
  468.   
  469.     
  470.   /* interpolation */
  471.   /* shift by 11 to make it a number between 0 & 1 in Q15 */
  472.   interp_factor = shl_a((Shortword)(x&(Shortword)0x000f),11); //   logic();   data_move();mark del
  473.   temp1 = sub(table[index2],table[index1]);
  474.   /* interp_component = mult(temp1,interp_factor);  //  data_move();mark del */
  475.   L_temp = _smpy(temp1,interp_factor);  //  data_move();mark del
  476.   interp_component = (Shortword) (0x0000ffffL & (L_temp >> 16));
  477.   
  478.   /* L_y in Q12 if x >= 0 and in Q_table[temp2]+12 if x < 0 */
  479.  /*  temp1 = add(table[index1], interp_component);                       */
  480. /*   temp2 = add(ten_multiple,4);                                        */
  481. /*   L_y = L_mult(tens_table[temp2],temp1);  //   L_data_move();mark del */
  482.   L_temp = _sadd2((Longword)(table[index1]),(Longword)interp_component);
  483.   temp1 = (Shortword) (0x0000ffffL & L_temp);
  484.   L_temp = _sadd2((Longword)ten_multiple,(Longword)4);
  485.   temp2 = (Shortword) (0x0000ffffL & L_temp);
  486.   L_y = _smpy(tens_table[temp2],temp1);  //   L_data_move();mark del
  488.   /* increment complexity for if statement */
  489. //  compare_zero();mark del
  490.   if (ten_multiple >= 0)
  491.     {
  492.       /* temp1 = sub(12,Q);       */
  493. /*       L_y = L_shr(L_y, temp1); */
  494. /*       y = extract_l(L_y);      */
  495.       temp1 = sub(12,Q);
  496.       L_y = _sshvr(L_y, temp1);
  497.       y = (Shortword) (0x0000ffffL & L_y);
  498.       
  499.   temp = (Shortword) (0x0000ffffL & (L_y >> 16));
  500.       if (temp) {
  501. y=SW_MAX; //   data_move();mark del
  502. saturation = saturation + 1;
  503.       }
  504.     }
  505.   else
  506.     {
  507.      /*  temp1 = add(Q_table[temp2],12); */
  508.   L_temp = _sadd2((Longword)(Q_table[temp2]),(Longword)12);
  509.   temp1 = (Shortword) (0x0000ffffL & L_temp);
  510.       temp1 = sub(temp1,Q);
  511.      /*  y = extract_l(L_shr(L_y, temp1)); */
  512.   L_temp = _sshvr(L_y, temp1);
  513.   y = (Shortword) (0x0000ffffL & L_temp);
  514.     }
  515.   
  516.   return(y);
  517. } /* pow10_fxp */
  521. /***************************************************************************
  522.  *
  523.  *   FUNCTION NAME: sqrt_fxp
  524.  *
  525.  *   PURPOSE:
  526.  *
  527.  *     Compute the square root of x.
  528.  *
  529.  *
  530.  *   INPUTS:
  531.  *
  532.  *     x
  533.  *                     16 bit short signed integer (Shortword).
  534.  *     Q
  535.  *                     16 bit short signed integer (Shortword) represents
  536.  *                     Q value of x.
  537.  *
  538.  *   OUTPUTS:
  539.  *
  540.  *     none
  541.  *
  542.  *   RETURN VALUE:
  543.  *
  544.  *     temp
  545.  *                     16 bit short signed integer (Shortword) in same Q.
  546.  *
  547.  *************************************************************************/
  548. Shortword sqrt_fxp(Shortword x, Shortword Q)
  549. {
  550.   Shortword temp;
  551.   
  552.   Longword L_temp;
  554.   /* increment complexity for if statement */
  555.  // compare_zero();mark del  @@@@@
  556.   if (!x)
  557.     return((Shortword)0);
  559.   /* temp = shr(log10_fxp(x,Q),1); */
  560.   temp = log10_fxp(x,Q);
  561.   L_temp = _shr2((Longword)temp,1);
  562.   temp = (Shortword) (0x0000ffffL & L_temp);
  563.   temp = pow10_fxp(temp,Q);
  565.   return (temp);
  566. }
  569. /***************************************************************************
  570.  *
  571.  *   FUNCTION NAME: L_sqrt_fxp
  572.  *
  573.  *   PURPOSE:
  574.  *
  575.  *     Compute the square root of x.
  576.  *
  577.  *
  578.  *   INPUTS:
  579.  *
  580.  *     x
  581.  *                     32 bit long signed integer (Longword).
  582.  *     Q
  583.  *                     16 bit short signed integer (Shortword) represents
  584.  *                     Q value of x.
  585.  *
  586.  *   OUTPUTS:
  587.  *
  588.  *     none
  589.  *
  590.  *   RETURN VALUE:
  591.  *
  592.  *     temp
  593.  *                     16 bit short signed integer (Shortword) in same Q.
  594.  *
  595.  *************************************************************************/
  596. Shortword L_sqrt_fxp(Longword x, Shortword Q)
  597. {
  598.   Shortword temp;
  600.   /* increment complexity for if statement */
  601. //  compare_zero();@@@@@
  602.   if (!x)
  603.     return((Shortword)0);
  605.   temp = L_log10_fxp(x,Q);
  606.   /* temp in Q11, pow10 treat it as Q12, => no need to shr by 1. */
  607.   temp = pow10_fxp(temp,Q);
  609.   return (temp);
  610. }
  613. /***************************************************************************
  614.  *
  615.  *   FUNCTION NAME: L_pow_fxp
  616.  *
  617.  *   PURPOSE:
  618.  *
  619.  *     Compute the value of x raised to the power 'power'.
  620.  *
  621.  *
  622.  *   INPUTS:
  623.  *
  624.  *     x
  625.  *                     32 bit long signed integer (Longword).
  626.  *     power
  627.  *                     16 bit short signed integer (Shortword) in Q15.
  628.  *     Q_in
  629.  *                     16 bit short signed integer (Shortword) represents
  630.  *                     Q value of x.
  631.  *     Q_out
  632.  *                     16 bit short signed integer (Shortword) represents
  633.  *                     required Q value of returned result.
  634.  *
  635.  *   OUTPUTS:
  636.  *
  637.  *     none
  638.  *
  639.  *   RETURN VALUE:
  640.  *
  641.  *     temp
  642.  *                     16 bit short signed integer (Shortword).
  643.  *
  644.  *************************************************************************/
  645. Shortword L_pow_fxp(Longword x,Shortword power,Shortword Q_in,Shortword Q_out)
  646. {
  647.   Shortword temp;
  649.   Longword L_temp;
  651.   /* increment complexity for if statement */
  652. //  compare_zero();@@@@@
  653.   if (!x)
  654.     return((Shortword)0);
  656.   temp = L_log10_fxp(x,Q_in);   /* temp in Q11 */
  657. /*   temp = mult(power,shl(temp,1)); //  data_move();  mark del  temp in Q12 */ 
  658.   L_temp = _smpy(power,shl_a(temp,1)); 
  659.   temp = (Shortword) (0x0000ffffL & (L_temp >> 16));
  661.   temp = pow10_fxp(temp,Q_out);
  663.   return (temp);
  664. }
  667. /***************************************************************************
  668.  *
  669.  *   FUNCTION NAME: sin_fxp
  670.  *
  671.  *   PURPOSE:
  672.  *
  673.  *     Compute the sine of x whose value is expressed in radians/PI.
  674.  *
  675.  *
  676.  *   INPUTS:
  677.  *
  678.  *     x
  679.  *                     16 bit short signed integer (Shortword) in Q15.
  680.  *
  681.  *   OUTPUTS:
  682.  *
  683.  *     none
  684.  *
  685.  *   RETURN VALUE:
  686.  *
  687.  *     ty
  688.  *                     16 bit short signed integer (Shortword) in Q15.
  689.  *
  690.  *************************************************************************/
  692. #define PI_Q13     24576    /* M_PI*(1<<13) */
  694. Shortword sin_fxp(Shortword x)
  695. {
  696.     static Shortword table[129] =
  697.     { 
  698.             0,   402,   804,  1206,  1608,  2009,  2411,  2811,  3212,
  699.  3612,  4011,  4410,  4808,  5205,  5602,  5998,  6393,  6787,
  700.  7180,  7571,  7962,  8351,  8740,  9127,  9512,  9896, 10279,
  701. 10660, 11039, 11417, 11793, 12167, 12540, 12910, 13279, 13646,
  702. 14010, 14373, 14733, 15091, 15447, 15800, 16151, 16500, 16846,
  703. 17190, 17531, 17869, 18205, 18538, 18868, 19195, 19520, 19841,
  704. 20160, 20475, 20788, 21097, 21403, 21706, 22006, 22302, 22595,
  705. 22884, 23170, 23453, 23732, 24008, 24279, 24548, 24812, 25073,
  706. 25330, 25583, 25833, 26078, 26320, 26557, 26791, 27020, 27246,
  707. 27467, 27684, 27897, 28106, 28311, 28511, 28707, 28899, 29086,
  708. 29269, 29448, 29622, 29792, 29957, 30118, 30274, 30425, 30572,
  709. 30715, 30853, 30986, 31114, 31238, 31357, 31471, 31581, 31686,
  710. 31786, 31881, 31972, 32058, 32138, 32214, 32286, 32352, 32413,
  711. 32470, 32522, 32568, 32610, 32647, 32679, 32706, 32729, 32746,
  712. 32758, 32766, 32767
  713.     };
  714.     
  715.     Shortword tx, ty;
  716.     Shortword sign;
  717.     Shortword index1,index2;
  718.     Shortword m;
  719.     Shortword temp;
  721. Longword L_temp,L_ty;
  723.     sign = 0;
  724.     if (x < 0) {
  725.         tx = negate(x); //    data_move();mark del
  726. sign = -1;  //   data_move();mark del
  727.     }
  728.     else {
  729.       tx = x;   //  data_move();mark del
  730.     }
  732.     /* if angle > pi/2, sin(angle) = sin(pi-angle) */
  733.     if (tx > X05_Q15)
  734.     {
  735.         tx = sub(ONE_Q15,tx); //    data_move();mark del
  736.     }
  737.     /* convert input to be within range 0-128 */
  738.     /* index1 = shr(tx,7);   //  data_move();mark del     */
  739. /*     index2 = add(index1,1);   //  data_move();mark del */
  740.       L_temp = _shr2((Longword)tx,7);
  741.   index1 = (Shortword) (0x0000ffffL & L_temp);
  742.   L_temp = _sadd2(L_temp,(Longword)1);
  743.   index2 = (Shortword) (0x0000ffffL & L_temp);
  745.     
  746.     /* increment complexity for if statement */
  747. //    compare_nonzero();mark del
  748.     if (index1 == 128) {
  749.       if (sign != 0)
  750.         return(negate(table[index1]));
  751.       else
  752. return(table[index1]);
  753.     }
  754.     
  755.     m = sub(tx,shl_a(index1,7));
  756.     /* convert decimal part to Q15 */
  757.     m = shl_a(m,8); //    data_move();mark del
  759.     /* interpolate */
  760.     temp = sub(table[index2],table[index1]);
  761.  /*    temp = mult(m,temp);                                     */
  762. /*     ty = add(table[index1],temp);  //   data_move();mark del */
  763.     L_temp = _smpy(m,temp);
  764. temp = (Shortword) (0x0000ffffL & (L_temp >> 16));
  765. L_ty = _sadd2((Longword)(table[index1]),(Longword)temp);
  766. ty = (Shortword) (0x0000ffffL & L_ty);
  768.     /* increment complexity for if statement */
  769. //    compare_zero();mark del
  770.     if (sign != 0)
  771.         return(negate(ty));
  772.     else
  773.         return(ty);
  774. } /* sin_fxp */
  777. /***************************************************************************
  778.  *
  779.  *   FUNCTION NAME: cos_fxp
  780.  *
  781.  *   PURPOSE:
  782.  *
  783.  *     Compute the cosine of x whose value is expressed in radians/PI.
  784.  *
  785.  *
  786.  *   INPUTS:
  787.  *
  788.  *     x
  789.  *                     16 bit short signed integer (Shortword) in Q15.
  790.  *
  791.  *   OUTPUTS:
  792.  *
  793.  *     none
  794.  *
  795.  *   RETURN VALUE:
  796.  *
  797.  *     ty
  798.  *                     16 bit short signed integer (Shortword) in Q15.
  799.  *
  800.  *************************************************************************/
  801. Shortword cos_fxp(Shortword x)
  802. {
  803.     static Shortword table[129] =
  804.     { 
  805.         32767, 32766, 32758, 32746, 32729, 32706, 32679, 32647, 32610,
  806.         32568, 32522, 32470, 32413, 32352, 32286, 32214, 32138, 32058,
  807.         31972, 31881, 31786, 31686, 31581, 31471, 31357, 31238, 31114,
  808.         30986, 30853, 30715, 30572, 30425, 30274, 30118, 29957, 29792,
  809.         29622, 29448, 29269, 29086, 28899, 28707, 28511, 28311, 28106,
  810.         27897, 27684, 27467, 27246, 27020, 26791, 26557, 26320, 26078,
  811.         25833, 25583, 25330, 25073, 24812, 24548, 24279, 24008, 23732,
  812.         23453, 23170, 22884, 22595, 22302, 22006, 21706, 21403, 21097,
  813.         20788, 20475, 20160, 19841, 19520, 19195, 18868, 18538, 18205,
  814.         17869, 17531, 17190, 16846, 16500, 16151, 15800, 15447, 15091,
  815.         14733, 14373, 14010, 13646, 13279, 12910, 12540, 12167, 11793,
  816.         11417, 11039, 10660, 10279,  9896,  9512,  9127,  8740,  8351,
  817.         7962,   7571,  7180,  6787,  6393,  5998,  5602,  5205,  4808,
  818.         4410,   4011,  3612,  3212,  2811,  2411,  2009,  1608,  1206,
  819.         804,     402,     0
  820.     };
  821.     
  822.     Shortword tx, ty;
  823.     Shortword sign;
  824.     Shortword index1,index2;
  825.     Shortword m;
  826.     Shortword temp;
  828. Longword L_temp,L_ty;
  830.     sign = 0;
  831.     /* increment complexity for if statement */
  832.   //  compare_zero();mark del
  833.     if (x < 0) {
  834.       tx = negate(x);   //  data_move();mark del
  835.     }
  836.     else {
  837.         tx = x;  //   data_move();mark del
  838.     }
  840.     /* if angle > pi/2, cos(angle) = -cos(pi-angle) */
  841.     /* increment complexity for if statement */
  842. //    compare_nonzero();mark del
  843.     if (tx > X05_Q15)
  844.     {
  845.         tx = sub(ONE_Q15,tx);  //   data_move();mark del
  846.         sign = -1;    // data_move();mark del
  847.     }
  848.     /* convert input to be within range 0-128 */
  849.     /* index1 = shr(tx,7);    // data_move();mark del     */
  850. /*     index2 = add(index1,1);  //   data_move();mark del */
  851.       L_temp = _shr2((Longword)tx,7);
  852.   index1 = (Shortword) (0x0000ffffL & L_temp);
  853.   L_temp = _sadd2(L_temp,(Longword)1);
  854.   index2 = (Shortword) (0x0000ffffL & L_temp);
  855.     
  856.     /* increment complexity for if statement */
  857. //    compare_nonzero();mark del
  858.     if (index1 == 128)
  859.         return((Shortword)0);
  860.     
  861.     m = sub(tx,shl_a(index1,7));
  862.     /* convert decimal part to Q15 */
  863.     m = shl_a(m,8);   //  data_move();mark del
  865.     temp = sub(table[index2],table[index1]);
  866.   /*   temp = mult(m,temp);                                     */
  867. /*     ty = add(table[index1],temp);  //   data_move();mark del */
  868.     L_temp = _smpy(m,temp);
  869.   temp = (Shortword) (0x0000ffffL & (L_temp >> 16));  
  870. L_ty = _sadd2((Longword)(table[index1]),(Longword)temp);
  871.     ty = (Shortword) (0x0000ffffL & L_ty);
  873.     /* increment complexity for if statement */
  874. //    compare_zero();mark del
  875.     if (sign != 0)
  876.         return(negate(ty));
  877.     else
  878.         return(ty);
  879. } /* cos_fxp */