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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 语音压缩 > 查看源码
UTIL_LBC.C
资源名称：G711-729.rar　[点击查看]
上传用户：meifeng08
上传日期：2013-06-18
资源大小：5304k
文件大小：20k
源码类别：

语音压缩

开发平台：

C/C++

UTIL_LBC.C：源码内容
  1. /*
  2. **
  3. ** File:    util_lbc.c
  4. **
  5. ** Description: utility functions for the lbc codec
  6. **
  7. ** Functions:
  8. **
  9. **  I/O functions:
  10. **
  11. **      Read_lbc()
  12. **      Write_lbc()
  13. **
  14. **  High-pass filtering:
  15. **
  16. **      Rem_Dc()
  17. **
  18. **  Miscellaneous signal processing functions:
  19. **
  20. **      Vec_Norm()
  21. **      Mem_Shift()
  22. **      Comp_En()
  23. **      Scale()
  24. **
  25. **  Bit stream packing/unpacking:
  26. **
  27. **      Line_Pack()
  28. **      Line_Unpk()
  29. **
  30. **  Mathematical functions:
  31. **
  32. **      Sqrt_lbc()
  33. **      Rand_lbc()
  34. */
  36. /*
  37.     ITU-T G.723 Speech Coder   ANSI-C Source Code     Version 5.00
  38.     copyright (c) 1995, AudioCodes, DSP Group, France Telecom,
  39.     Universite de Sherbrooke.  All rights reserved.
  40. */
  43. #include <stdlib.h>
  44. #include <stdio.h>
  46. #include "typedef.h"
  47. #include "basop.h"
  48. #include "cst_lbc.h"
  49. #include "tab_lbc.h"
  50. #include "lbccodec.h"
  51. #include "coder.h"
  52. #include "decod.h"
  53. #include "util_lbc.h"
  55. /*
  56. **
  57. ** Function:        Read_lbc()
  58. **
  59. ** Description:     Read in a file
  60. **
  61. ** Links to text:   Sections 2.2 & 4
  62. **
  63. ** Arguments:
  64. **
  65. **  Word16 *Dpnt
  66. **  int     Len
  67. **  FILE *Fp
  68. **
  69. ** Outputs:
  70. **
  71. **  Word16 *Dpnt
  72. **
  73. ** Return value:    None
  74. **
  75. */
  76. void  Read_lbc( Word16 *Dpnt, int Len, FILE *Fp )
  77. {
  78.     int   i  ;
  80.     for ( i = 0 ; i < Len ; i ++ )
  81.         Dpnt[i] = (Word16) 0 ;
  83.     fread ( (char *)Dpnt, sizeof(Word16), Len, Fp ) ;
  85.     return;
  86. }
  88. /*
  89. **
  90. ** Function:        Write_lbc()
  91. **
  92. ** Description:     Write a file
  93. **
  94. ** Links to text:   Section
  95. **
  96. ** Arguments:
  97. **
  98. **  Word16 *Dpnt
  99. **  int     Len
  100. **  FILE *Fp
  101. **
  102. ** Outputs:         None
  103. **
  104. ** Return value:    None
  105. **
  106. */
  107. void    Write_lbc( Word16 *Dpnt, int Len, FILE *Fp )
  108. {
  109.     fwrite( (char *)Dpnt, sizeof(Word16), Len, Fp ) ;
  110. }
  112. void    Line_Wr( char *Line, FILE *Fp )
  113. {
  114.     Word16  Info ;
  115.     int     Size   ;
  117.     Info = Line[0] & (Word16)0x0003 ;
  119.     /* Check frame type and rate informations */
  120.     switch (Info) {
  122.         case 0x0002 : {   /* SID frame */
  123.             Size  = 4;
  124.             break;
  125.         }
  127.         case 0x0003 : {  /* untransmitted silence frame */
  128.             Size  = 1;
  129.             break;
  130.         }
  132.         case 0x0001 : {   /* active frame, low rate */
  133.             Size  = 20;
  134.             break;
  135.         }
  137.         default : {  /* active frame, high rate */
  138.             Size  = 24;
  139.         }
  140.     }
  141.     fwrite( Line, Size , 1, Fp ) ;
  142. }
  144. int Line_Rd( char *Line, FILE *Fp )
  145. {
  146.     Word16  Info ;
  147.     int     Size   ;
  149.     if(fread( Line, 1,1, Fp ) != 1) return(-1);
  151.     Info = Line[0] & (Word16)0x0003 ;
  153.     /* Check frame type and rate informations */
  154.     switch(Info) {
  156.         /* Active frame, high rate */
  157.         case 0 : {
  158.             Size  = 23;
  159.             break;
  160.         }
  162.         /* Active frame, low rate */
  163.         case 1 : {
  164.             Size  = 19;
  165.             break;
  166.         }
  168.         /* Sid Frame */
  169.         case 2 : {
  170.             Size  = 3;
  171.             break;
  172.         }
  174.         /* untransmitted */
  175.         default : {
  176.             return(0);
  177.         }
  178.     }
  179.     fread( &Line[1], Size , 1, Fp ) ;
  180.     return(0);
  181. }
  183. /*
  184. **
  185. ** Function:        Rem_Dc()
  186. **
  187. ** Description:     High-pass filtering
  188. **
  189. ** Links to text:   Section 2.3
  190. **
  191. ** Arguments:
  192. **
  193. **  Word16 *Dpnt
  194. **
  195. ** Inputs:
  196. **
  197. **  CodStat.HpfZdl  FIR filter memory from previous frame (1 word)
  198. **  CodStat.HpfPdl  IIR filter memory from previous frame (1 word)
  199. **
  200. ** Outputs:
  201. **
  202. **  Word16 *Dpnt
  203. **
  204. ** Return value:    None
  205. **
  206. */
  207. void  Rem_Dc( Word16 *Dpnt )
  208. {
  209.     int   i  ;
  212.     Word32   Acc0,Acc1 ;
  214.     if ( UseHp ) {
  215.         for ( i = 0 ; i < Frame ; i ++ ) {
  217.             /* Do the Fir and scale by 2 */
  218.             Acc0 = L_mult( Dpnt[i], (Word16) 0x4000 ) ;
  219.             Acc0 = L_mac ( Acc0, CodStat.HpfZdl, (Word16) 0xc000 ) ;
  220.             CodStat.HpfZdl = Dpnt[i] ;
  222.             /* Do the Iir part */
  223.             Acc1 = L_mls( CodStat.HpfPdl, (Word16) 0x7f00 ) ;
  224.             Acc0 = L_add( Acc0, Acc1 ) ;
  225.             CodStat.HpfPdl = Acc0 ;
  226.             Dpnt[i] = round(Acc0) ;
  227.         }
  228.     }
  229.     else {
  230.         for ( i = 0 ; i < Frame ; i ++ )
  231.             Dpnt[i] = shr( Dpnt[i], (Word16) 1 ) ;
  232.     }
  234.     return;
  235. }
  237. /*
  238. **
  239. ** Function:        Vec_Norm()
  240. **
  241. ** Description:     Vector normalization
  242. **
  243. ** Links to text:
  244. **
  245. ** Arguments:
  246. **
  247. **  Word16 *Vect
  248. **  Word16 Len
  249. **
  250. ** Outputs:
  251. **
  252. **  Word16 *Vect
  253. **
  254. ** Return value:  The power of 2 by which the data vector multiplyed.
  255. **
  256. */
  257. Word16  Vec_Norm( Word16 *Vect, Word16 Len )
  258. {
  259.     int   i  ;
  261.     Word16  Acc0,Acc1   ;
  262.     Word16  Exp   ;
  263.     Word16  Rez ;
  264.     Word32  Temp  ;
  266.     static   short ShiftTable[16] = {
  267.       0x0001 ,
  268.       0x0002 ,
  269.       0x0004 ,
  270.       0x0008 ,
  271.       0x0010 ,
  272.       0x0020 ,
  273.       0x0040 ,
  274.       0x0080 ,
  275.       0x0100 ,
  276.       0x0200 ,
  277.       0x0400 ,
  278.       0x0800 ,
  279.       0x1000 ,
  280.       0x2000 ,
  281.       0x4000 ,
  282.       0x7fff
  283.    } ;
  285.     /* Find absolute maximum */
  286.     Acc1 = (Word16) 0 ;
  287.     for ( i = 0 ; i < Len ; i ++ ) {
  288.         Acc0 = abs_s( Vect[i] ) ;
  289.         if ( Acc0 > Acc1 )
  290.             Acc1 = Acc0 ;
  291.     }
  293.     /* Get the shift count */
  294.     Rez = norm_s( Acc1 ) ;
  295.     Exp = ShiftTable[Rez] ;
  297.     /* Normalize all the vector */
  298.     for ( i = 0 ; i < Len ; i ++ ) {
  299.         Temp = L_mult( Exp, Vect[i] ) ;
  300.         Temp = L_shr( Temp, 4 ) ;
  301.         Vect[i] = extract_l( Temp ) ;
  302.     }
  304.     Rez = sub( Rez, (Word16) 3) ;
  305.     return Rez ;
  306. }
  308. /*
  309. **
  310. ** Function:        Mem_Shift()
  311. **
  312. ** Description:     Memory shift, update of the high-passed input speech signal
  313. **
  314. ** Links to text:
  315. **
  316. ** Arguments:
  317. **
  318. **  Word16 *PrevDat
  319. **  Word16 *DataBuff
  320. **
  321. ** Outputs:
  322. **
  323. **  Word16 *PrevDat
  324. **  Word16 *DataBuff
  325. **
  326. ** Return value:    None
  327. **
  328. */
  329. void  Mem_Shift( Word16 *PrevDat, Word16 *DataBuff )
  330. {
  331.     int   i  ;
  333.     Word16   Dpnt[Frame+LpcFrame-SubFrLen] ;
  335.     /*  Form Buffer  */
  336.     for ( i = 0 ; i < LpcFrame-SubFrLen ; i ++ )
  337.         Dpnt[i] = PrevDat[i] ;
  338.     for ( i = 0 ; i < Frame ; i ++ )
  339.         Dpnt[i+LpcFrame-SubFrLen] = DataBuff[i] ;
  341.     /* Update PrevDat */
  342.     for ( i = 0 ; i < LpcFrame-SubFrLen ; i ++ )
  343.         PrevDat[i] = Dpnt[Frame+i] ;
  345.     /* Update DataBuff */
  346.     for ( i = 0 ; i < Frame ; i ++ )
  347.         DataBuff[i] = Dpnt[(LpcFrame-SubFrLen)/2+i] ;
  349.     return;
  350. }
  352. /*
  353. **
  354. ** Function:        Line_Pack()
  355. **
  356. ** Description:     Packing coded parameters in bitstream of 16-bit words
  357. **
  358. ** Links to text:   Section 4
  359. **
  360. ** Arguments:
  361. **
  362. **  LINEDEF *Line     Coded parameters for a frame
  363. **  char    *Vout     bitstream chars
  364. **  Word16   VadBit   Voice Activity Indicator
  365. **
  366. ** Outputs:
  367. **
  368. **  Word16 *Vout
  369. **
  370. ** Return value:    None
  371. **
  372. */
  373. void    Line_Pack( LINEDEF *Line, char *Vout, Word16 Ftyp )
  374. {
  375.     int     i ;
  376.     int     BitCount ;
  378.     Word16  BitStream[192] ;
  379.     Word16 *Bsp = BitStream ;
  380.     Word32  Temp ;
  382.     /* Clear the output vector */
  383.     for ( i = 0 ; i < 24 ; i ++ )
  384.         Vout[i] = 0 ;
  386.  /*
  387.   * Add the coder rate info and frame type info to the 2 msb
  388.   * of the first word of the frame.
  389.   * The signaling is as follows:
  390.   *     Ftyp  WrkRate => X1X0
  391.   *       1     Rate63     00  :   High Rate
  392.   *       1     Rate53     01  :   Low  Rate
  393.   *       2       x        10  :   Silence Insertion Descriptor frame
  394.   *       0       x        11  :   Used only for simulation of
  395.   *                                 untransmitted silence frames
  396.   */
  397.     switch (Ftyp) {
  399.         case 0 : {
  400.             Temp = 0x00000003L;
  401.             break;
  402.         }
  404.         case 2 : {
  405.             Temp = 0x00000002L;
  406.             break;
  407.         }
  409.         default : {
  410.             if ( WrkRate == Rate63 )
  411.                 Temp = 0x00000000L ;
  412.             else
  413.                 Temp = 0x00000001L ;
  414.             break;
  415.         }
  416.     }
  418.     /* Serialize Control info */
  419.     Bsp = Par2Ser( Temp, Bsp, 2 ) ;
  422.     /* Check for Speech/NonSpeech case */
  423.     if ( Ftyp == 1 ) {
  425.     /* 24 bit LspId */
  426.     Temp = (*Line).LspId ;
  427.     Bsp = Par2Ser( Temp, Bsp, 24 ) ;
  429.  /*
  430.   * Do the part common to both rates
  431.   */
  433.         /* Adaptive code book lags */
  434.         Temp = (Word32) (*Line).Olp[0] - (Word32) PitchMin ;
  435.         Bsp = Par2Ser( Temp, Bsp, 7 ) ;
  437.         Temp = (Word32) (*Line).Sfs[1].AcLg ;
  438.         Bsp = Par2Ser( Temp, Bsp, 2 ) ;
  440.         Temp = (Word32) (*Line).Olp[1] - (Word32) PitchMin ;
  441.         Bsp = Par2Ser( Temp, Bsp, 7 ) ;
  443.         Temp = (Word32) (*Line).Sfs[3].AcLg ;
  444.         Bsp = Par2Ser( Temp, Bsp, 2 ) ;
  446.         /* Write combined 12 bit index of all the gains */
  447.         for ( i = 0 ; i < SubFrames ; i ++ ) {
  448.             Temp = (*Line).Sfs[i].AcGn*NumOfGainLev + (*Line).Sfs[i].Mamp ;
  449.             if ( WrkRate == Rate63 )
  450.                 Temp += (Word32) (*Line).Sfs[i].Tran << 11 ;
  451.             Bsp = Par2Ser( Temp, Bsp, 12 ) ;
  452.         }
  454.         /* Write all the Grid indices */
  455.         for ( i = 0 ; i < SubFrames ; i ++ )
  456.             *Bsp ++ = (*Line).Sfs[i].Grid ;
  458.         /* High rate only part */
  459.         if ( WrkRate == Rate63 ) {
  461.             /* Write the reserved bit as 0 */
  462.             *Bsp ++ = (Word16) 0 ;
  464.             /* Write 13 bit combined position index */
  465.             Temp = (*Line).Sfs[0].Ppos >> 16 ;
  466.             Temp = Temp * 9 + ( (*Line).Sfs[1].Ppos >> 14) ;
  467.             Temp *= 90 ;
  468.             Temp += ((*Line).Sfs[2].Ppos >> 16) * 9 + ( (*Line).Sfs[3].Ppos >> 14 ) ;
  469.             Bsp = Par2Ser( Temp, Bsp, 13 ) ;
  471.             /* Write all the pulse positions */
  472.             Temp = (*Line).Sfs[0].Ppos & 0x0000ffffL ;
  473.             Bsp = Par2Ser( Temp, Bsp, 16 ) ;
  475.             Temp = (*Line).Sfs[1].Ppos & 0x00003fffL ;
  476.             Bsp = Par2Ser( Temp, Bsp, 14 ) ;
  478.             Temp = (*Line).Sfs[2].Ppos & 0x0000ffffL ;
  479.             Bsp = Par2Ser( Temp, Bsp, 16 ) ;
  481.             Temp = (*Line).Sfs[3].Ppos & 0x00003fffL ;
  482.             Bsp = Par2Ser( Temp, Bsp, 14 ) ;
  484.             /* Write pulse amplitudes */
  485.             Temp = (Word32) (*Line).Sfs[0].Pamp ;
  486.             Bsp = Par2Ser( Temp, Bsp, 6 ) ;
  488.             Temp = (Word32) (*Line).Sfs[1].Pamp ;
  489.             Bsp = Par2Ser( Temp, Bsp, 5 ) ;
  491.             Temp = (Word32) (*Line).Sfs[2].Pamp ;
  492.             Bsp = Par2Ser( Temp, Bsp, 6 ) ;
  494.             Temp = (Word32) (*Line).Sfs[3].Pamp ;
  495.             Bsp = Par2Ser( Temp, Bsp, 5 ) ;
  496.         }
  498.         /* Low rate only part */
  499.         else {
  501.             /* Write 12 bits of positions */
  502.             for ( i = 0 ; i < SubFrames ; i ++ ) {
  503.                 Temp = (*Line).Sfs[i].Ppos ;
  504.                 Bsp = Par2Ser( Temp, Bsp, 12 ) ;
  505.             }
  507.             /* Write 4 bit Pamps */
  508.             for ( i = 0 ; i < SubFrames ; i ++ ) {
  509.                 Temp = (*Line).Sfs[i].Pamp ;
  510.                 Bsp = Par2Ser( Temp, Bsp, 4 ) ;
  511.             }
  512.         }
  514.     }
  516.     else if(Ftyp == 2) {   /* SID frame */
  518.         /* 24 bit LspId */
  519.         Temp = (*Line).LspId ;
  520.         Bsp = Par2Ser( Temp, Bsp, 24 ) ;
  522.         /* Do Sid frame gain */
  523.         Temp = (Word32)(*Line).Sfs[0].Mamp ;
  524.         Bsp = Par2Ser( Temp, Bsp, 6 ) ;
  525.     }
  527.     /* Write out active frames */
  528.     if ( Ftyp == 1 ) {
  529.         if ( WrkRate == Rate63 )
  530.             BitCount = 192 ;
  531.         else
  532.             BitCount = 160 ;
  533.     }
  534.     /* Non active frames */
  535.     else if ( Ftyp == 2 )
  536.         BitCount = 32 ;
  537.     else
  538.         BitCount = 2;
  540.     for ( i = 0 ; i < BitCount ; i ++ )
  541.         Vout[i>>3] ^= BitStream[i] << (i & 0x0007) ;
  543.     return;
  544. }
  546. Word16* Par2Ser( Word32 Inp, Word16 *Pnt, int BitNum )
  547. {
  548.     int i   ;
  549.     Word16  Temp ;
  551.     for ( i = 0 ; i < BitNum ; i ++ ) {
  552.         Temp = (Word16) Inp & (Word16)0x0001 ;
  553.         Inp >>= 1 ;
  554.         *Pnt ++ = Temp ;
  555.     }
  557.     return Pnt ;
  558. }
  560. /*
  561. **
  562. ** Function:        Line_Unpk()
  563. **
  564. ** Description:     unpacking of bitstream, gets coding parameters for a frame
  565. **
  566. ** Links to text:   Section 4
  567. **
  568. ** Arguments:
  569. **
  570. **  char   *Vinp        bitstream chars
  571. **  Word16 *VadType
  572. **
  573. ** Outputs:
  574. **
  575. **  Word16 *VadType
  576. **
  577. ** Return value:
  578. **
  579. **  LINEDEF             coded parameters
  580. **     Word16   Crc
  581. **     Word32   LspId
  582. **     Word16   Olp[SubFrames/2]
  583. **     SFSDEF   Sfs[SubFrames]
  584. **
  585. */
  586. LINEDEF  Line_Unpk( char *Vinp, Word16 *Ftyp, Word16 Crc )
  587. {
  588.     int   i  ;
  589.     Word16  BitStream[192] ;
  590.     Word16 *Bsp = BitStream ;
  591.     LINEDEF Line ;
  592.     Word32  Temp ;
  593.     Word16  Info;
  594.     Word16 Bound_AcGn;
  596.     Line.Crc = Crc;
  597.     if(Crc != 0) return Line;
  599.     /* Unpack the byte info to BitStream vector */
  600.     for ( i = 0 ; i < 192 ; i ++ )
  601.         BitStream[i] = ( Vinp[i>>3] >> (i & (Word16)0x0007) ) & (Word16)1 ;
  603.     /* Decode the frame type and rate info */
  604.     Info = (Word16)Ser2Par( &Bsp, 2 ) ;
  606.     if ( Info == 3 ) {
  607.         *Ftyp = 0;
  608.         Line.LspId = 0L;    /* Dummy : to avoid Borland C3.1 warning */
  609.         return Line;
  610.     }
  612.     /* Decode the LspId */
  613.     Line.LspId = Ser2Par( &Bsp, 24 ) ;
  615.     if ( Info == 2 ) {
  616.         /* Decode the Noise Gain */
  617.         Line.Sfs[0].Mamp = (Word16)Ser2Par( &Bsp, 6);
  618.         *Ftyp = 2;
  619.         return Line ;
  620.     }
  622.  /*
  623.   * Decode the common information to both rates
  624.   */
  625.     *Ftyp = 1;
  627.     /* Decode the bit-rate */
  628.     WrkRate = (Info == 0) ? Rate63 : Rate53;
  630.     /* Decode the adaptive codebook lags */
  631.     Temp = Ser2Par( &Bsp, 7 ) ;
  632.     /* Test if forbidden code */
  633.     if( Temp <= 123) {
  634.         Line.Olp[0] = (Word16) Temp + (Word16)PitchMin ;
  635.     }
  636.     else {
  637.         /* transmission error */
  638.         Line.Crc = 1;
  639.         return Line ;
  640.     }
  642.     Line.Sfs[1].AcLg = (Word16) Ser2Par( &Bsp, 2 ) ;
  644.     Temp = Ser2Par( &Bsp, 7 ) ;
  645.     /* Test if forbidden code */
  646.     if( Temp <= 123) {
  647.         Line.Olp[1] = (Word16) Temp + (Word16)PitchMin ;
  648.     }
  649.     else {
  650.         /* transmission error */
  651.         Line.Crc = 1;
  652.         return Line ;
  653.     }
  655.     Line.Sfs[3].AcLg = (Word16) Ser2Par( &Bsp, 2 ) ;
  657.     Line.Sfs[0].AcLg = 1 ;
  658.     Line.Sfs[2].AcLg = 1 ;
  660.     /* Decode the combined gains accordingly to the rate */
  661.     for ( i = 0 ; i < SubFrames ; i ++ ) {
  663.         Temp = Ser2Par( &Bsp, 12 ) ;
  665.         Line.Sfs[i].Tran = 0 ;
  666.         Bound_AcGn = NbFilt170 ;
  667.         if ( (WrkRate == Rate63) && (Line.Olp[i>>1] < (SubFrLen-2) ) ) {
  668.             Line.Sfs[i].Tran = (Word16)(Temp >> 11) ;
  669.             Temp &= 0x000007ffL ;
  670.             Bound_AcGn = NbFilt085 ;
  671.         }
  672.         Line.Sfs[i].AcGn = (Word16)(Temp / (Word16)NumOfGainLev) ;
  673.         if(Line.Sfs[i].AcGn < Bound_AcGn ) {
  674.             Line.Sfs[i].Mamp = (Word16)(Temp % (Word16)NumOfGainLev) ;
  675.         }
  676.         else {
  677.             /* error detected */
  678.             Line.Crc = 1;
  679.             return Line ;
  680.         }
  681.     }
  683.     /* Decode the grids */
  684.     for ( i = 0 ; i < SubFrames ; i ++ )
  685.         Line.Sfs[i].Grid = *Bsp ++ ;
  687.     if (Info == 0) {
  689.         /* Skip the reserved bit */
  690.         Bsp ++ ;
  692.         /* Decode 13 bit combined position index */
  693.         Temp = Ser2Par( &Bsp, 13 ) ;
  694.         Line.Sfs[0].Ppos = ( Temp/90 ) / 9 ;
  695.         Line.Sfs[1].Ppos = ( Temp/90 ) % 9 ;
  696.         Line.Sfs[2].Ppos = ( Temp%90 ) / 9 ;
  697.         Line.Sfs[3].Ppos = ( Temp%90 ) % 9 ;
  699.         /* Decode all the pulse positions */
  700.         Line.Sfs[0].Ppos = ( Line.Sfs[0].Ppos << 16 ) + Ser2Par( &Bsp, 16 ) ;
  701.         Line.Sfs[1].Ppos = ( Line.Sfs[1].Ppos << 14 ) + Ser2Par( &Bsp, 14 ) ;
  702.         Line.Sfs[2].Ppos = ( Line.Sfs[2].Ppos << 16 ) + Ser2Par( &Bsp, 16 ) ;
  703.         Line.Sfs[3].Ppos = ( Line.Sfs[3].Ppos << 14 ) + Ser2Par( &Bsp, 14 ) ;
  705.         /* Decode pulse amplitudes */
  706.         Line.Sfs[0].Pamp = (Word16)Ser2Par( &Bsp, 6 ) ;
  707.         Line.Sfs[1].Pamp = (Word16)Ser2Par( &Bsp, 5 ) ;
  708.         Line.Sfs[2].Pamp = (Word16)Ser2Par( &Bsp, 6 ) ;
  709.         Line.Sfs[3].Pamp = (Word16)Ser2Par( &Bsp, 5 ) ;
  710.     }
  712.     else {
  714.         /* Decode the positions */
  715.         for ( i = 0 ; i < SubFrames ; i ++ )
  716.             Line.Sfs[i].Ppos = Ser2Par( &Bsp, 12 ) ;
  718.         /* Decode the amplitudes */
  719.         for ( i = 0 ; i < SubFrames ; i ++ )
  720.             Line.Sfs[i].Pamp = (Word16)Ser2Par( &Bsp, 4 ) ;
  721.     }
  722.    return Line ;
  723. }
  725. Word32  Ser2Par( Word16 **Pnt, int Count )
  726. {
  727.     int     i ;
  728.     Word32  Rez = 0L ;
  730.     for ( i = 0 ; i < Count ; i ++ ) {
  731.         Rez += (Word32) **Pnt << i ;
  732.         (*Pnt) ++ ;
  733.     }
  734.     return Rez ;
  735. }
  737. /*
  738. **
  739. ** Function:        Comp_En()
  740. **
  741. ** Description:     Compute energy of a subframe vector
  742. **
  743. ** Links to text:
  744. **
  745. ** Arguments:
  746. **
  747. **  Word16 *Dpnt
  748. **
  749. ** Outputs:         None
  750. **
  751. ** Return value:
  752. **
  753. **      Word32 energy
  754. **
  755. */
  756. Word32   Comp_En( Word16 *Dpnt )
  757. {
  758.     int   i ;
  759.     Word32   Rez ;
  760.     Word16   Temp[SubFrLen] ;
  762.     for ( i = 0 ; i < SubFrLen ; i ++ )
  763.         Temp[i] = shr( Dpnt[i], (Word16) 2 ) ;
  765.     Rez = (Word32) 0 ;
  766.     for ( i = 0 ; i < SubFrLen ; i ++ )
  767.         Rez = L_mac( Rez, Temp[i], Temp[i] ) ;
  769.     return Rez ;
  770. }
  772. /*
  773. **
  774. ** Function:        Sqrt_lbc()
  775. **
  776. ** Description:     Square root computation
  777. **
  778. ** Links to text:
  779. **
  780. ** Arguments:
  781. **
  782. **  Word32 Num
  783. **
  784. ** Outputs:     None
  785. **
  786. ** Return value:
  787. **
  788. **  Word16 square root of num
  789. **
  790. */
  791. Word16   Sqrt_lbc( Word32 Num )
  792. {
  793.     int   i  ;
  795.     Word16   Rez = (Word16) 0 ;
  796.     Word16   Exp = (Word16) 0x4000 ;
  798.     Word32   Acc ;
  800.     for ( i = 0 ; i < 14 ; i ++ ) {
  802.         Acc = L_mult( add(Rez, Exp), add(Rez, Exp) ) ;
  803.         if ( Num >= Acc )
  804.             Rez = add( Rez, Exp ) ;
  806.         Exp = shr( Exp, (Word16) 1 ) ;
  807.     }
  808.     return Rez ;
  809. }
  811. /*
  812. **
  813. ** Function:        Rand_lbc()
  814. **
  815. ** Description:     Generator of random numbers
  816. **
  817. ** Links to text:   Section 3.10.2
  818. **
  819. ** Arguments:
  820. **
  821. **  Word16 *p
  822. **
  823. ** Outputs:
  824. **
  825. **  Word16 *p
  826. **
  827. ** Return value:
  828. **
  829. **  Word16 random number
  830. **
  831. */
  832. Word16   Rand_lbc( Word16 *p )
  833. {
  834.     Word32   Temp ;
  836.     Temp = L_deposit_l( *p ) ;
  837.     Temp &= (Word32) 0x0000ffff ;
  838.     Temp = Temp*(Word32)521 + (Word32) 259 ;
  839.     *p = extract_l( Temp ) ;
  840.     return extract_l( Temp ) ;
  841. }
  843. /*
  844. **
  845. ** Function:        Scale()
  846. **
  847. ** Description:     Postfilter gain scaling
  848. **
  849. ** Links to text:   Section 3.9
  850. **
  851. ** Arguments:
  852. **
  853. **  Word16 *Tv
  854. **  Word32 Sen
  855. **
  856. **  Inputs:
  857. **
  858. **  Word16 DecStat.Gain
  859. **
  860. ** Outputs:
  861. **
  862. **  Word16 *Tv
  863. **
  864. ** Return value:    None
  865. **
  866. */
  867. void  Scale( Word16 *Tv, Word32 Sen )
  868. {
  869.     int   i ;
  871.     Word32   Acc0,Acc1   ;
  872.     Word16   Exp,SfGain  ;
  875.     Acc0 = Sen ;
  876.     Acc1 = Comp_En( Tv ) ;
  878.     /* Normalize both */
  879.     if ( (Acc1 != (Word32) 0) && (Acc0 != (Word32) 0 ) ) {
  881.         Exp = norm_l( Acc1 ) ;
  882.         Acc1 = L_shl( Acc1, Exp ) ;
  884.         SfGain = norm_l( Acc0 ) ;
  885.         Acc0 = L_shl( Acc0, SfGain ) ;
  886.         Acc0 = L_shr( Acc0, (Word16) 1 ) ;
  887.         Exp = sub( Exp, SfGain ) ;
  888.         Exp = add( Exp, (Word16) 1 ) ;
  889.         Exp = sub( (Word16) 6, Exp ) ;
  890.         if ( Exp < (Word16) 0 )
  891.             Exp = (Word16) 0 ;
  893.         SfGain = extract_h( Acc1 ) ;
  895.         SfGain = div_l( Acc0, SfGain ) ;
  897.         Acc0 = L_deposit_h( SfGain ) ;
  899.         Acc0 = L_shr( Acc0, Exp ) ;
  901.         SfGain = Sqrt_lbc( Acc0 ) ;
  902.     }
  903.     else
  904.         SfGain = 0x1000 ;
  906.     /* Filter the data */
  907.     for ( i = 0 ; i < SubFrLen ; i ++ ) {
  909.         /* Update gain */
  910.         Acc0 = L_deposit_h( DecStat.Gain ) ;
  911.         Acc0 = L_msu( Acc0, DecStat.Gain, (Word16) 0x0800 ) ;
  912.         Acc0 = L_mac( Acc0, SfGain, (Word16) 0x0800 ) ;
  913.         DecStat.Gain = round( Acc0 ) ;
  915.         Exp = add( DecStat.Gain, shr( DecStat.Gain, (Word16) 4) ) ;
  917.         Acc0 = L_mult( Tv[i], Exp ) ;
  918.         Acc0 = L_shl( Acc0, (Word16) 4 ) ;
  919.         Tv[i] = round( Acc0 ) ;
  920.     }
  922.     return;
  923. }