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

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

语音压缩

开发平台：

C/C++

celp.c：源码内容
  1. /**************************************************************************
  2. *                                                                         *
  3. * CELP Voice Coder                                                  *
  4. * Version 3.2c                                                   *
  5. *   *
  6. * The U.S. Government shall not be held liable for any damages      *
  7. * resulting from this code.  Further reproduction or distribution   *
  8. * of this code without prior written permission of the U.S.         *
  9. * Government is prohibited.                                     *
  10. *                                                                         *
  11. ***************************************************************************
  12. *
  13. * ROUTINE
  14. * celp (main)
  15. *
  16. * FUNCTION
  17. * Codebook excited linear predictor (main routine)
  18. *
  19. ***************************************************************************
  20. *
  21. * REFERENCES
  22. *
  23. C National Communication System Technical Information Bulletin
  24. C Federal Standard 1016 (to be published 1992).
  25. C
  26. C Campbell, Joseph P. Jr., Thomas E. Tremain and Vanoy C. Welch,
  27. C "The Federal Standard 1016 4800 bps CELP Voice Coder," Digital
  28. C Signal Processing, Academic Press, Vol1, No. 3, p. 145-155.
  29. C
  30. C Kemp, David, P., Retha A. Sueda and Thomas E. Tremain, "An
  31. C Evaluation of 4800 bps Voice Coders," Proceedings of the IEEE
  32. C International Conference on Acoustics, Speech and Signal Processing
  33. C (ICASSP), 1989, p. 200-203.
  34. C
  35. C Fenichel, R., "Federal Standard 1016," National Communications
  36. C System, Office of Technology and Standards, Washington, DC 20305-2010,
  37. C 14 February 1991.
  38. C
  39. C Campbell, Joseph P. Jr., Thomas E. Tremain and Vanoy C. Welch,
  40. C "The DoD 4.8 kbps Standard (Proposed Federal Standard 1016),"
  41. C "Advances in Speech Coding", Kluwer Academic Publishers, 1991,
  42. C Chapter 12, p. 121-133.
  43. C
  44. C   Tutorials:
  45. C Fallside, Frank and William Woods, Computer Speech Processing,
  46. C Prentice Hall International, 1985, Chapter 4 (by Bishnu Atal).
  47. *
  48. ***************************************************************************
  49. *
  50. * 4800 bps CELP Characteristics
  51. *
  52. *                  Spectrum       Pitch            Code Book
  53. *                  -------------  ---------------  -----------------
  54. *       Update     30 ms          30/4 = 7.5 ms    30/4 = 7.5 ms
  55. *                  ll=240         lp=60            l=60
  56. *
  57. *       Order      10             256 (max) x 60   512 (max) x 60
  58. *   1 gain    1 gain
  59. *
  60. *       Analysis   Open loop      Closed loop      Closed loop
  61. *                  Correlation    Modified MSPE    MSPE VQ
  62. *                  30 ms Hamming  VQ, weight=0.8   weight=0.8
  63. *                  no preemphasis range 20 to 147  shift by 2
  64. *                  15 Hz BW exp   (w/ fractions)   77% sparsity
  65. *
  66. *       Bits per   34 indep LSP   index:  8+6+8+6  index:     9*4
  67. *        Frame     [3444433333]   gain(-1,2): 5*4  gain(+/-): 5*4
  68. *
  69. *       Bit Rate   1133.3 bps     1600 bps       1866.67 bps
  70. *
  71. * NOTE:  The remaining 200 bps are used as follows:  1 bit per frame
  72. * for synchronization, 4 bits per frame for forward error correction
  73. * and 1 bit per frame to provide future expansion(s) of the coder.
  74. *
  75. ***************************************************************************
  76. *
  77. * UNPERMUTED BIT ASSIGNMENT
  78. *
  79. * lsp  1 1-3 lsp  6 20-22
  80. * lsp  2 4-7 lsp  7 23-25
  81. * lsp  3 8-11 lsp  8 26-28
  82. * lsp  4 12-15 lsp  9 29-31
  83. * lsp  5 16-19 lsp 10 32-34
  84. *
  85. * Subframe:   1   2   3    4
  86. * ---------- ----- ----- -----  -------
  87. *       pitch delay 35-42 ..... 87-94  .......
  88. *       delta delay ..... 62-67 .......  114-119
  89. *       pitch gain  43-47 68-72 95-99  120-124
  90. *       cbindex 48-56 73-81 100-108  125-133
  91. *       cbgain 57-61 82-86 109-113  134-138
  92. *
  93. *       future bit 139
  94. *       error control 140-143
  95. *       sync 144
  96. *
  97. * FORWARD ERROR CONTROL, HAMMING (15,11):
  98. * bits protected allocation rate parameter
  99. * 0 1 LSP
  100. * 40,41,42,92,93,94 1st-3rd MSBs 2 Pitch delay
  101. * 0 2 Delta pitch delay
  102. * 47,72,99,124     1st MSB 4 Pitch gain
  103. * 0 4 CB index
  104. * 0 4 CB gain
  105. * 139 1 1 Future bit
  106. *
  107. * SYNCHRONIZATION BIT
  108. * The sync bit (144) begins with 0 in the first frame, then alternates 
  109. * between 1 and 0 on successive frames.
  110. *
  111. ***************************************************************************
  112. * 
  113. * INPUT FILES
  114. * ifile.spd  speech
  115. * ifile.chan channel (use for synthesis only)
  116. * codebook.h stochastic code book
  117. * pdelay.h adaptive code book (pitch) delay
  118. * pdencode.h pitch delay bit assignment encoding table
  119. * pddecode.h pitch delay bit assignment decoding table
  120. * submult.h submultiple pitch delay pointer table
  121. * bitprot.h bit protection (specifies FEC bits)
  122. * bitperm.h bit permutation (for burst errors)
  123. *
  124. * OUTPUT FILES
  125. * ofile.spd  speech (without high pass)
  126. * ofilehpf.spd speech (high pass)
  127. * ofilenpf.spd speech (no post filtering)
  128. * ofile.chan bit stream channel file
  129. *
  130. * Sungraph (tm) Files:
  131. * ifile_ofile.sg_data
  132. * channel.sg_data
  133. * stream_error.sg_data
  134. * lsp1.sg_data   see sungraph_open.h
  135. * lsp2.sg_data
  136. * codebook.sg_data
  137. * constrain.sg_data
  138. * pitch.sg_data
  139. * error.sg_data
  140. * rc.sg_data
  141. *
  142. **************************************************************************
  143. * 
  144. *   global
  145. *
  146. *
  147. * SPECTRUM VARIABLES:
  148. * fc float LPC filter/weighting filter coefficients
  149. * fcn float new weighting filter coefficients
  150. * fci float interpolated weighting filter coefficients
  151. * gamma2 float weight factor
  152. * no int filter order  predictor
  153. *
  154. * PITCH VARIABLES:
  155. * bb float pitch predictor coefficients
  156. * idb int dimension of d1a and d1b???
  157. * tauptr  int pitch delay pointer
  158. * minptr int minimum delay pointer
  159. * pbits int pitch gain coding bit allocation
  160. * pindex int pitch gain index bb[2]
  161. * ptype char pitch gain (bb[2]) quantizer type
  162. * prewt   real pitch prefilter weighting (0.0 = off)
  163. * pstype  char    pitch search type (hier, full, or intg)
  164. * pdelay float pitch delay coding table
  165. * plevel1 float number of full search pitch delays
  166. * plevel2 float number of delta search pitch delays
  167. *
  168. * CODE BOOK VARIABLES:
  169. * cbgbits int code book gain bit allocation
  170. * cbgtype char code book gain quantizer type
  171. * mxsw int modified excitation switch on(1) or off(0)
  172. * cbindex int code book index
  173. * e0 float initial error and updated error
  174. * gindex int gain index
  175. * h float impulse response
  176. * ncsize int code book size
  177. * nseg int segment counter
  178. * x float code book
  179. *
  180. *
  181. * MISCELLANEOUS:
  182. * frame int frame counter
  183. *
  184. **************************************************************************/
  185. #ifdef STREAMLINE
  186. #undef SUNGRAPH
  187. #endif
  189. #ifndef ANALY
  190. #undef SUNGRAPH
  191. #endif
  193. #define TRUE 1
  194. #define FALSE 0
  195. #define STREAMBITS 144
  196. #define CODELENGTH1 15
  197. #define CODELENGTH2 11
  198. #define PARITYLENGTH (CODELENGTH1 - CODELENGTH2)
  199. #define SYNDRUN 100
  200. #define OMEGA 0.994127  /* Bandwidth expansion for LPC analysis (15 Hz) */
  201. #define ALPHA 0.8  /* Bandwidth expansion for postfilter */
  202. #define BETA 0.5  /* Bandwidth expansion for postfilter */
  203. #define I2 1  /* symbolic disk_io data type */
  204. #define I4 2  /* symbolic disk_io data type */
  205. #define R4 3  /* symbolic disk_io data type */
  206. #define mmax(A,B)        ((A)>(B)?(A):(B))
  207. #define mmin(A,B)        ((A)<(B)?(A):(B))
  208. #include <stdio.h>
  209. #include <math.h>
  210. #include <strings.h>
  211. /* #include <floatingpoint.h> /* uncomment if you use ieee_handler below */
  212. #include "ccsub.h"
  214. int cbgbits = 5, cbindex = 0, gindex = 0, idb = 0, ncsize = 512, no = 10;
  215. int nseg = 0, pindex = 0, frame = 0, tauptr = 0, minptr = 0, plevel1 = 0;
  216. int plevel2 = 0, pbits[MAXNP + 2] = {8, 6, 5, 0, 0};
  217. int mxsw = 1;
  219. float bb[MAXNP + 1], e0[MAXLP];
  220. float fc[MAXNO + 1], fcn[MAXNO + 1], fci[MAXNO + 1];
  221. float h[MAXLP], gamma2 = 0.8, prewt = 0.0;
  223.   /* *read adaptive code book index (pitch delay) file */
  224. float pdelay[MAXPD] = 
  225. {
  226. #include "pdelay.h"
  227. };
  229.   /* *load stochastic code book vector file */
  230. float x[MAXCODE] = 
  231. {
  232. #include "codebook.h"
  233. };
  235. char ptype[10] = "max2", cbgtype[10] = "log";
  236. char pstype[10] = "hier"; 
  238. #ifdef SUNGRAPH
  239. int ifile_vid, ifile_hp_vid, ofile_npf_vid, ofile_pf_vid, ofile_hpf_vid;
  240. int channel_vid, gain_vid, ccor_vid, dbcon_vid;
  241. int stream_vid, stream_error_vid, stream_error_s_vid, bit_error_vid;
  242. int lsp_vid[MAXNO], qlsp_vid[MAXNO], lsp_analy_vid[MAXNO];
  243. int lsp_synth_vid[MAXNO], cb_gain_vid, cb_qgain_vid, cb_qgain_synth_vid;
  244. int cb_match_vid, cb_index_vid, cb_index_synth_vid, cb_exc_vid;
  245. int cb_ir_vid, pitch_gain_vid, pitch_qgain_vid, pitch_qgain_synth_vid; 
  246. int pitch_match_vid, pitch_tau_vid, pitch_tau_synth_vid, pitch_ir_vid;
  247. int fndex_e0_vid, fndpp_e0_vid, fndpp_v0_vid, rc_vid[MAXNO];
  248. #endif
  250. main(argc, argv)
  251. int argc;
  252. char *argv[];
  254. {
  256.   int cbi[MAXLL / MAXL], framesnr = 0;
  257.   int framedm = 0, framedm2 = 0, i, j, k, l = 60, lun[10];
  258.   int ll = 240, lp = 60, nn, np = 1, nrec1 = 1, nrec2 = 1, nrec3 = 1;
  259.   int findex[MAXNO];
  260.   int error = 0, total = 0, flag, snrflag, lspflag;
  261.   int pdtabi[MAXPD], sync = 1;
  263.   short iarf[MAXLL], npf[MAXLL], pf[MAXLL];
  265.   float cbg[MAXLL / MAXL], pgs[MAXLL / MAXL];
  266.   float sold[MAXLL], snew[MAXLL], ssub[MAXLL], v[MAXLL];
  267.   float vdecoded[MAXLL], rcn[MAXNO], hamw[MAXLL], hamws[MAXL], dpa[MAXPA];
  268.   float dps[MAXPA], newfreq[MAXNO], unqfreq[MAXNO], lsp[MAXLL / MAXL][MAXNO];
  269.   float dppa[MAXPA], dpps[MAXPA]; 
  270.   float scale = 1.0, decodedgain, dm[9], dm2[9], taus[4], descale = 1.0;
  272.   /* *load pitch delay coding tables for bit assignment */
  273.   /* *pdencode.h for encoding, pddecode.h for decoding  */
  274.   static int pdencode[MAXPD] = 
  275.   {
  276. #include "pdencode.h"
  277.   };
  279.   static float pddecode[MAXPD] = 
  280.   {
  281. #include "pddecode.h"
  282.   };
  284.   /* *filter coefficients for 2nd order 100 Hz HPF with 60 Hz notch: */
  285.   /* static float ahpf[3] = {1.0, -1.99778, 1.0};  */
  286.   /* static float bhpf[3] = {1.0, -1.88 0.89};  */
  288.   /* *filter coefficients for 2nd order Butterworth 100 Hz HPF: */
  289.   static float ahpf[3] = {0.946, -1.892, 0.946};
  290.   static float bhpf[3] = {1.0, -1.889033, 0.8948743};
  292.   /* *filter coefficients for 2nd order Butterworth 275 Hz HPF: */
  293.   /* static float ahpfo[3] = {0.858, -1.716, 0.858}; */
  294.   /* static float bhpfo[3] = {1.0, -1.696452, 0.7368054}; */
  296.   static float ahpfo[3] = {0.946, -1.892, 0.946};
  297.   static float bhpfo[3] = {1.0, -1.889033, 0.8948743};
  300. /*
  301. *bit stream 
  302. */
  304.   int cbbits = 9, pointer, bitpointer, bitsum1, bitsum2;
  305.   int mask[STREAMBITS], ssum, pstream[STREAMBITS]; 
  306.   static int sbits[MAXNO] = {3, 4, 4, 4, 4, 3, 3, 3, 3, 3};
  307.   short stream[STREAMBITS], savestream[STREAMBITS];
  308.   char line[38];
  310. /*
  311. *filter memories (should be maxno+1)
  312. */
  314.   static float dhpf1[3], dhpf2[3], dsa[MAXNO+1], dss[MAXNO+1];
  315.   static float dhpf1o[3], dhpf2o[3];
  316.   static float dp1[MAXNO+1], dp2[MAXNO+1], dp3[2];
  317.   static float ip, op, sumsnr, sumdm[10], sumdm2[10];
  319. /*
  320. *error control coding parameters:
  321. */
  322.   float ber = 0.0, realerror, syndavg = 0.0;
  323.   int codeword[CODELENGTH1], hmatrix[CODELENGTH1];
  324.   int syndrometable[CODELENGTH1], paritybit, twoerror, protect;
  325.   int syndrome, eccbits = 5;
  327.   /* *load bit protection vector  */
  328.   static int bitprotect[CODELENGTH2] = 
  329.   {
  330. #include "bitprot.h"
  331.   };
  333.   /* *load bit permutation vector  */
  334.   static int bitpermute[STREAMBITS] = 
  335.   {
  336. #include "bitperm.h"
  337.   };
  339.   char tempstr[82];
  341. #ifdef ANALY
  342.   static char ifile[82] = "dam2.spd";
  343. #else
  344.   static char ifile[82] = "ofile.chan";
  345. #endif
  347.   static char ofile[82] = "ofile";
  348.   static char stype[12] = "kang";
  350.   FILE *fopen(), *fp25;
  352.   
  355. #ifdef SUNGRAPH
  356.   /* ********************** sungraph*******************************/
  357.   
  358.   /* define sungraph files   */
  360.   int input_fid, ifile_ofile_fid, channel_fid, lsp1_fid, lsp2_fid;
  361.   int cb_fid, pitch_fid, error_fid, stream_error_fid, rc_fid;
  362.   int constrain_fid;
  363.   char str[19];
  364.   short s_zero = 0;
  365.   float f_zero = 0.0;
  368.   /*  *nonhigh-passed old input speech for alignment     */
  370.   float ssubnhp[MAXLL], soldnhp[MAXLL];
  372.   /* *sungraph variable id's  */
  374.   int status, num_read;
  375.   
  376.   short iint;
  377.   
  378. #else
  380.   int nrec9 = 1;
  382. #endif
  385.   /* *start CELP   */
  387.   /* *set the IEEE underflow mode just like the FORTRAN  */
  388.   /* *if you uncomment the following, be sure to uncomment */
  389.   /* *the #include <floatingpoint.h> above */
  390.   /* ieee_handler("set","underflow", SIGFPE_DEFAULT); /* */
  392. #ifndef STREAMLINE
  393.   /* *** parse the command line
  394.   
  395.   celp [-i ifile] [-o ofile] [-p pfile] [-q qfile] [-l lfile]
  396.   celp [-c chan]  [-o ofile]
  398.      note:  ncsize, no, and gamma2 are external variables
  399.      note:  The calls to cli & cliend may be commented out and celp will
  400.      operate properly with default values (without bells & whistles)
  403.      ... If synthesizer only, the celp command syntax for synthesis only 
  404.      is:
  406.      celp -c input.chan  -o ofile
  408.      where: input.chan is a ascii hex bit stream channel file
  409.     ofile is a ofile.spd speech file (postfiltered)
  411. *set analysis or synthesis only with the ANALY macro,
  412. *read command line,
  413. *and enable/disable sungraph files
  414.   */
  417.   /* *intialize mask */
  419.   for (i = 0; i < STREAMBITS; i++)
  420.   {
  421.     mask[i] = 0;
  422.   }
  424.   cli(ifile, ofile, &l, &ll, &lp, &np, &scale, &descale, &ber, mask, stype,
  425.       sbits, &eccbits, &ssum, argc, argv);
  427. #endif
  429.   /* ********************* initialize********************  */
  431.   /* *number of codewords/LPC frame  */
  433.   nn = ll / l;
  435.   /* *dimension of d1a and d1b???  */
  437.   idb = MMAX + MAXNP - 1 + l;
  438.   plevel1 = 1 << pbits[0];
  440.   /* *levels of delta tau  */
  442.   plevel2 = 1 << pbits[1];
  444.   /* *number of bits per subframe  */
  446.   bitsum1 = cbbits + cbgbits + pbits[0] + pbits[2];
  447.   bitsum2 = cbbits + cbgbits + pbits[1] + pbits[2];
  449.   /* *enable/disable error control coding  */
  451.   protect = TRUE;
  453.   /* *for double error detecting FEC codes (NOT USED) */
  455.   twoerror = FALSE;
  456.   snrflag = FALSE;
  457.   lspflag = TRUE;
  459.   /* *intialize arrays */
  461.   for (i = 0; i < MAXLP; i++) h[i] = e0[i] = 0.0;
  462.   for (i = 0; i < MAXLL; i++) sold[i] = 0.0;
  463.   for (i = 0; i < STREAMBITS; i++) stream[i] = savestream[i] = 0;
  465.   /* *start nseg at 0 to do pitch on odd segments  */
  466.   /*   (nseg is incremented before csub)  */
  468.   nseg = 0;
  470.   /* *generate matrix for error control coding  */
  472.   matrixgen(CODELENGTH1, CODELENGTH2, hmatrix, syndrometable);
  474.   /* *generate Hamming windows  */
  476.   ham(hamw, ll);
  478.   /*  *UNNECESSARY, used for distortion diagnostics */
  480.   ham(hamws, l);
  482.   /* *** open and define files  */
  484. #ifdef SUNGRAPH
  485.   /* *sungraph (tm) files  */
  487. #include "sungraph_open.h"
  489. #else
  490.   /* *input file  */
  492.   if (iodisk(3, &lun[9], ifile, &nrec9, iarf, ll) != 0)
  493.   {
  494.     fprintf(stderr, "*** Error opening ifile.spdn");
  495.     exit(1);
  496.   }
  497. #endif
  500.   /* *postfiltered & nonpostfiltered output  */
  502.   if (iodisk(4, &lun[1], strcat(strcpy(tempstr, ofile), ".spd"),
  503.      &nrec1, pf, l) != 0)
  504.   {
  505.     fprintf(stderr, "celp: *** Error opening ofile.spdn");
  506.     exit(1);
  507.   }
  509. #ifndef STREAMLINE
  510.   if (iodisk(4, &lun[2], strcat(strcpy(tempstr, ofile), "npf.spd"),
  511.      &nrec2, npf, l) != 0)
  512.   {
  513.     fprintf(stderr, "celp: *** Error opening ofilenpf.spdn");
  514.     exit(1);
  515.   }
  517.   if (iodisk(4, &lun[3], strcat(strcpy(tempstr, ofile), "hpf.spd"),
  518.      &nrec3, pf, l) != 0)
  519.   {
  520.     fprintf(stderr, "celp: *** Error opening ofilehpf.spdn");
  521.     exit(1);
  522.   }
  524.   /* *bit stream channel file */
  525. #ifdef ANALY
  526.   fp25 = fopen(strcat(strcpy(tempstr, ofile), ".chan"), "w");
  527.   if (fp25 == NULL)
  528.   {
  529.     perror("celp: Error opening the channel file");
  530.     exit(0);
  531.   }
  532. #else
  533.   fp25 = fopen(ifile, "r");
  534.   if (fp25 == NULL)
  535.   {
  536.     perror("celp: Error opening the channel file");
  537.     exit(0);
  538.   }
  539. #endif
  541. #endif
  544.   /* *generate pdtabi for delta delay coding */
  545.   for (i = 0; i < MAXPD; i++)
  546.   {
  547.     pdtabi[pdencode[i]] = i;
  548.   }
  550.   /* ......................... m a i n  l o o p ........................ */
  552.   /* *** ANALYSIS ...................................................... */
  554.   /* *if synthesizer only, skip analyzer >>>>>>>>>>>>>>>>>>>  */
  556. #ifdef ANALY
  557.   /* *** LPC spectral analysis (open loop)  */
  558.   /* NOTE: Autocorrelation was found superior to covariance analysis   */
  560.   /* *** read speech segment s of size ll, until end of file  */
  562. #ifdef SUNGRAPH
  563.   while ((status = read_variable(input_fid, iarf, ll, &num_read)) != -5)
  564.   {
  565.     if (status < 0)
  566.       read_error(status, "read_input_fid");
  568. #else
  569.   while (iodisk(1, &lun[9], ifile, &nrec9, iarf, ll) == ll)
  570.   {
  571. #endif
  572.     
  573.     frame++;
  574.     pointer = 0;
  576.     /* *display a propeller (rotating bar) once per frame  */
  578.     mark(0);
  579.     /* fprint(stderr,"frame =  ",frame);  */
  582.     /*        *scale and convert to real speech  */
  583.     /* *The ssub buffer used for subframe CELP analysis is 1/2 a  */
  584.     /* *frame behind the snew buffer and 1/2 a frame ahead of the   */
  585.     /* *sold buffer.  */
  587.     for (i = 0; i < ll; i++)
  588.       snew[i] = mmax(-32768., mmin(scale * iarf[i], 32767.));
  590. #ifdef SUNGRAPH
  592.     /* *create ssubnhp vector for sungraph  */
  594.     for (i = 0; i < ll/2; i++)
  595.     {
  596.       ssubnhp[i] = soldnhp[i + ll/2];
  597.       ssubnhp[i + ll/2] = snew[i];
  598.     }
  600.     /* *save input speech in file 'ifile_ofile'    */
  602.     save_sg(ifile_vid, ssubnhp, ll, "save speech_in_vid");
  604.     /* *save snew in soldnhp for sungraph in next frame  */
  606.     for (i = 0; i < ll; i++)
  607.       soldnhp[i] = snew[i];
  608. #endif
  609.       
  610.     /* *high pass filter snew  */
  612.     zerofilt(ahpf, 2, dhpf1, snew, ll);
  613.     polefilt(bhpf, 2, dhpf2, snew, ll);
  615.     /* *make ssub vector from snew and sold    */
  617.     for (i = 0; i < ll/2; i++)
  618.     {
  619.       ssub[i] = sold[i + ll/2];
  620.       ssub[i + ll/2] = snew[i];
  621.     }
  623. #ifdef SUNGRAPH
  625.     /* *save high-passed future input in file 'ifile_ofile'  */
  627.     save_sg(ifile_hp_vid, ssub, ll, "save ifile_hp_vid");
  628. #endif
  630.     autohf(snew, hamw, ll, no, OMEGA, fcn, rcn);
  632. #ifdef SUNGRAPH
  633.     /* *save rc's in file 'rc'  */
  635.     for (i = 0; i < no; i++)
  636.       save_sg(rc_vid[i], &rcn[i], 1, "save rc_vid");
  637. #endif
  639.     /* *pc -> lsp (new)  */
  641.     pctolsp2(fcn, no, newfreq, &lspflag);
  642.     if (lspflag)
  643.     {
  644.       printf("celp: Bad "new" lsp at frame: %dn", frame);
  645.       printf("lsp: ");
  646.       for (i = 0; i < no; i++)
  647. printf("%9.5f", newfreq[i]);
  648.       printf("npc: ");
  649.       for (i = 0; i < no + 1; i++)
  650. printf("%9.5f", fcn[i]);
  651.       printf("nrc: ");
  652.       for (i = 0; i < no; i++)
  653. printf("%9.5f", rcn[i]);
  654.       printf("n");
  655.     }
  657.     /* *save unquantized lsp  */
  659.     for (i = 0; i < no; i++)
  660.       unqfreq[i] = newfreq[i];
  662.     /* *quantize lsp's    */
  664.     lsp34(newfreq, no, sbits, findex);
  666. #ifdef SUNGRAPH
  668.     /* *save future lsp variables in file 'lsp1'  */
  670.     for (i = 0; i < no; i++)
  671.     {
  672.       save_sg(lsp_vid[i], &unqfreq[i], 1, "save lsp_vid");
  673.     }
  675.     /* *save future qlsp variables in file 'lsp1'  */
  677.     for (i = 0; i < no; i++)
  678.     {
  679.       save_sg(qlsp_vid[i], &newfreq[i], 1, "save qlsp_vid");
  680.     }
  682. #endif
  684. #ifndef STREAMLINE
  685.     /* *measure spectral distortion  */
  686.     /* UNNECESSARY, used for diagnostices  */
  688.     specdist(unqfreq, newfreq, dm2, sumdm2, &framedm2);
  689. #endif
  691.     /* *pack lsp indices in bit stream array  */
  693.     for (i = 0; i < no; i++)
  694.       pack(findex[i], sbits[i], stream, &pointer);
  696.     /* *linearly interpolate LSP's for each subframe  */
  698.     intanaly(newfreq, nn, lsp);
  700.     /* *** for each subframe, search stochastic & adaptive code books    */
  702.     k = 0;
  703.     for (i = 0; i < nn; i++)
  704.     {
  706. #ifdef SUNGRAPH
  707.       /* *save interpolated lsp's in file 'lsp2'  */
  709.       for (j = 0; j < no; j++)
  710. save_sg(lsp_analy_vid[j], &lsp[i][j], 1, "save lsp_analy_vid");
  711. #endif
  713.       lsptopc(&lsp[i][0], fci);
  714.       for (j = 0; j < no + 1; j++)
  715. fc[j] = fci[j];
  716.       nseg++;
  718.       /* *** code book & pitch searches  */
  720.       csub(&ssub[k], &v[k], l, lp);
  722. #ifdef SUNGRAPH
  723.       /* *save code book index in file 'cbindex' */
  725.       save_sg(cb_index_vid, &cbindex, 1, "save cb_index_vid");
  727.       /* *save tau in file 'pitch'  */
  729.       save_sg(pitch_tau_vid, &bb[0], 1, "save pitch_tau_vid");
  730. #endif
  732.       /* *pitch quantization tau  */
  734.       /* *pack parameter indices in bit stream array  */
  736.       if (((i+1) % 2) != 0)
  737. packtau(tauptr-minptr, pbits[0], pdencode, stream, &pointer);
  738.       else
  739. pack(tauptr-minptr, pbits[1], stream, &pointer);
  741.       pack(pindex, pbits[2], stream, &pointer);
  742.       cbindex--;
  743.       pack(cbindex, cbbits, stream, &pointer);
  744.       pack(gindex, cbgbits, stream, &pointer);
  746.       /* *decode parameters for analysis by synthesis  */
  748.       cbindex++;
  750.       /* *pitch synthesis (UNNECESSARY, used for diagnostics) */
  752.       pitchvq(&v[k], l, dpa, idb, bb, "long");
  754.       /* *pitch pre filter (UNNECESSARY, used for diagnostics)  */
  756.       if (prewt != 0.0) 
  757.         prefilt(&v[k], l, dppa);
  759.       /* *lpc synthesis (UNNECESSARY, used for diagnostics)  */
  761.       polefilt(fci, no, dsa, &v[k], l);
  763.       k += l;
  764.     }
  766.     /* *** bit error protection  */
  767.     /* *extract bits to protect from stream array    */
  768.     if (protect)
  769.     {
  770.       for (i = 0; i < CODELENGTH2; i++)
  771. codeword[i] = stream[bitprotect[i] - 1];
  773.       /* *hamming encode  */
  775.       encodeham(CODELENGTH1, CODELENGTH2, hmatrix, &paritybit, codeword);
  777.       /* *pack future bit  */
  779.       pack(0, 1, stream, &pointer);
  781.       /* *pack parity bits  */
  783.       for (i = 0; i < PARITYLENGTH; i++)
  784. pack(codeword[CODELENGTH2 + i], 1, stream, &pointer);
  786.       /* *toggle and pack the sync bit */
  788.       sync = sync ^ 1;
  789.       pack(sync, 1, stream, &pointer);
  791.     }
  793. #ifdef SUNGRAPH
  794.     /* *save stream array in channel file  */
  796.     save_sg(channel_vid, stream, STREAMBITS, "save channel_vid");
  798.     /* *save stream array in stream_error file  */
  800.     save_sg(stream_vid, stream, STREAMBITS, "save stream_vid");
  801. #endif
  803. #ifndef STREAMLINE
  804.     /* *save stream  */
  806.     for (i = 0; i < STREAMBITS; i++)
  807.       savestream[i] = stream[i];
  809.     /* *permute bitstream     */
  811.     for (i = 0; i < STREAMBITS; i++)
  812.       pstream[i] = stream[bitpermute[i] - 1];
  814.     /* *save stream in Dave's format  */
  816.     puthex(STREAMBITS, pstream, line);
  817.     fprintf(fp25, "%sn", line);
  818. #endif
  820.     /* *synthesizer only <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<  */
  822. #else
  824.   /* *** CHANNEL ..................................................  */
  826.   /* *read in channel file (if synthesis only)  */
  827.   while (fscanf(fp25, "%s", line) != EOF)
  828.   {
  829.     pointer = -1; 
  830.     gethex(STREAMBITS, pstream, line);
  831.     frame++;
  833.     /* *display a propeller (rotating bar) once per frame  */
  835.     mark(0);
  836. #endif
  838. #ifndef STREAMLINE
  839.     /* *unpermute bitstream   */
  841.     for (i = 0; i < STREAMBITS; i++)
  842.       stream[bitpermute[i] - 1] = pstream[i];
  844.     /* *** corrupt the channel with bit errors   */
  846.     biterror(ber, mask, stream, STREAMBITS, &error, &total);
  848. #endif
  850. #ifdef SUNGRAPH
  851.     /* *save stream array in stream_error file  */
  853.     save_sg(stream_error_vid, stream, STREAMBITS, "save stream_error_vid");
  854. #endif
  856.     /* *** SYNTHESIS ..........................................  */
  858.     /* *unpack parity bits  */
  860.     if (protect)
  861.     {
  862.       pointer = pointer - PARITYLENGTH - 2;
  864. #ifndef ANALY
  865.       pointer = 138;
  866. #endif
  868.       for (i = 0; i < PARITYLENGTH; i++)
  869. unpack(stream, 1, &codeword[CODELENGTH2 + i], &pointer);
  871.       /* *extract code word from stream array  */
  873.       for (i = 0; i < CODELENGTH2; i++)
  874. codeword[i] = stream[bitprotect[i] - 1];
  876.       /* repack Bisnu bit (remains constant for now)  */
  878.       codeword[10] = 0;
  880.       /* *Hamming decode  */
  882.       decodeham(CODELENGTH1, hmatrix, syndrometable, paritybit, codeword,
  883.  &twoerror, &syndrome);
  885.       /* *disable parity check (if parity not used)  */
  886.       twoerror = FALSE;
  888.       /* *bit error rate estimator (running avg of bad syndromes)  */
  890.       if (syndrome != 0)
  891.         syndrome = 1;
  892.       syndavg = (1.0 - (1.0 / SYNDRUN)) * syndavg + (1.0 / SYNDRUN) * (float) syndrome;
  894.       /* *repack protected bits  */
  896.       for (i = 0; i < CODELENGTH2; i++)
  897. stream[bitprotect[i] - 1] = codeword[i];
  899. #ifdef SUNGRAPH
  900.       /* *save stream array in stream_error file  */
  902.       save_sg(stream_error_s_vid, stream, STREAMBITS, "save stream_error_s_vid");
  904.       /* *compare saved stream with channel stream  */
  906.       for (i = 0; i < STREAMBITS; i++)
  907.       {
  908. if (savestream[i] != stream[i])
  909. {
  910.   iint = 1;
  911.   save_sg(bit_error_vid, &iint, 1, "save bit_error_vid");
  912. }
  913. else
  914. {
  915.   iint = 0;
  916.   save_sg(bit_error_vid, &iint, 1, "save bit_error_vid");
  917. }
  918.       }
  920. #endif
  922.       /* *frame repeat if two errors detected in code word  */
  924.       if (twoerror)
  925. printf("celp: two errors have occured in frame %dn", frame);
  927.     }
  929.     pointer = -1;
  931.     /* *unpack data stream  */
  933.     for (i = 0; i < no; i++)
  934.       unpack(stream, sbits[i], &findex[i], &pointer);
  936.     /* *decode lsp's  */
  938.     lspdecode34(findex, no, newfreq);
  940.     /* *interpolate spectrum lsp's for nn subframes  */
  942.     intsynth(newfreq, nn, lsp, twoerror, syndavg);
  945.     /* *decode all code book and pitch parameters  */
  947.     bitpointer = pointer;
  948.     dcodtau(pbits[0], pbits[1], bitsum1, bitsum2, &bitpointer, nn, stream, pddecode, pdtabi, taus);
  949.     dcodpg(pbits[2], bitsum1, bitsum2, &bitpointer, nn, stream, pgs);
  950.     dcodcbi(cbbits, bitsum1, bitsum2, &bitpointer, nn, stream, cbi);
  951.     dcodcbg(cbgbits, bitsum1, bitsum2, &bitpointer, nn, stream, cbg);
  953.     /* *** synthesize each subframe  */
  955. #ifdef ANALY
  956.     nseg -= nn;
  957. #endif
  959.     k = 0;
  960.     for (i = 0; i < nn; i++)
  961.     {
  962.       nseg++;
  964. #ifdef SUNGRAPH
  965.       /* *save interpolated lsp's in file 'lsp2'  */
  967. for (j = 0; j < no; j++)
  968.   save_sg(lsp_synth_vid[j], &lsp[i][j], 1, "save lsp_synth_vid");
  969. #endif
  972.       /* *decode values for subframe  */
  974.       cbindex = cbi[i];
  975.       decodedgain = cbg[i];
  976.       if (protect)
  977. smoothcbgain(&decodedgain, twoerror, syndavg, cbg, i + 1);
  979.       /* *code book synthesis  */
  981.       vdecode(decodedgain, l, &vdecoded[k]);
  983.       if (protect)
  984. smoothtau(&taus[i], twoerror, syndavg, taus[2], i + 1);
  985.       bb[0] = taus[i];
  986.       bb[2] = pgs[i];
  987.       if (protect)
  988. smoothpgain(&bb[2], twoerror, syndavg, pgs, i + 1);
  990. #ifdef SUNGRAPH
  991.       /* *save synthesis parameters in sungraph files  */
  993.       save_sg(cb_index_synth_vid, &cbindex, 1, "save cb_index_synth_vid");
  994.       save_sg(pitch_tau_synth_vid, &bb[0], 1, "save pitch_tau_synth_vid");
  995.       save_sg(cb_qgain_synth_vid, &decodedgain, 1, "save cb_qgain_synth_vid");
  996.       save_sg(pitch_qgain_synth_vid, &bb[2], 1, "save pitch_qgain_synth_vid");
  997. #endif
  999.       /* *pitch synthesis  */
  1001.       pitchvq(&vdecoded[k], l, dps, idb, bb, "long");
  1003.       /* *pitch pre filter (synthesis)  */
  1005.       if (prewt != 0.0) 
  1006.         prefilt(&vdecoded[k], l, dpps);
  1008.       /* convert lsp's to pc's   */
  1010.       lsptopc(&lsp[i][0], fci);
  1012.       /* lpc synthesis    */ 
  1014.       polefilt(fci, no, dss, &vdecoded[k], l);
  1016. #ifndef STREAMLINE
  1017.       /* *** check analysis versus synthesis speech  */
  1019. #ifdef ANALY
  1020.       flag = FALSE;
  1021.       for (j = 0; j < l; j++)
  1022.       {
  1023. if (fabs(v[k + j] - vdecoded[k + j]) > 1.e-6)
  1024.   flag = TRUE;
  1025.       }
  1026.       if (flag)
  1027. printf("celp: Speech mismatch at frame %dn", frame);
  1028. #endif
  1030.       /* *** write nonpostfiltered output speech disk files  */
  1032.       for (j = 0; j < l; j++)
  1033.       {
  1034.         vdecoded[k + j] = descale * vdecoded[k + j];
  1035. npf[k + j] = nint(mmax(-32768., mmin(32767., vdecoded[k + j])));
  1036.       }
  1038.       /* *write npf output speech file "ofilenpf"  */
  1040.       if (iodisk(2, &lun[2], strcat(strcpy(tempstr, ofile), "npf.spd"),
  1041.  &nrec2, &npf[k], l) != l)
  1042.       {
  1043.         fprintf(stderr, "celp: *** Error writing ofilenpf.spdn");
  1044.         exit(1);
  1045.       }
  1047. #ifdef SUNGRAPH
  1048.       /* *sungraph's npf output speech file 'ifile_ofile'  */
  1050.       save_sg(ofile_npf_vid, &npf[k], l, "save ofile_npf_vid");
  1051. #endif
  1053.       /* *** calculate the average segmental SNR  */
  1054.       /* *UNNECESSARY, used for diagnostics  */
  1056. #ifdef ANALY
  1057.       segsnr(&ssub[k], &npf[k], l, &sumsnr, &framesnr, &snrflag);
  1059.       /* *** calculate distortions/distances (log spectral error, etc.)  */
  1060.       /* *UNNECESSARY, used for diagnostics  */
  1062.       if (snrflag)
  1063. distortion(&ssub[k], &npf[k], hamws, l, no, dm, sumdm, &framedm);
  1064. #endif
  1066. #endif
  1068.       /* *** post filtering  */
  1070.       postfilt(&vdecoded[k], l, ALPHA, BETA, &ip, &op, dp1, dp2, dp3);
  1072.       /* *** test for output speech clipping  */
  1074.       while (clip(&vdecoded[k], l))
  1075.       {
  1077.       /* frame repeat & recall synthesizer?   */
  1078.       /* or scale vdecoded?  */
  1080. printf("celp: Clipping detected at frame %dn", frame);
  1081.         for (j = 0; j < l; j++)
  1082.           vdecoded[k + j] = 0.05 * vdecoded[k + j]; 
  1083.       }
  1085.       /* *** write postfiltered output speech disk files  */
  1087.       for (j = 0; j < l; j++)
  1088. pf[k + j] = nint(mmax(-32768., mmin(32767., vdecoded[k + j])));
  1090.       /* *write output speech file "ofile"  */
  1092.       if (iodisk(2, &lun[1], strcat(strcpy(tempstr, ofile), ".spd")
  1093.  ,&nrec1, &pf[k], l) != l)
  1094.       {
  1095.         fprintf(stderr, "celp: *** Error writing ofile.spdn");
  1096.         exit(1);
  1097.       }
  1099. #ifdef SUNGRAPH
  1100.       /* *sungraph's output speech file 'ifile_ofile'  */
  1102.       save_sg(ofile_pf_vid, &pf[k], l, "save ofile_pf_vid");
  1103. #endif
  1105. #ifndef STREAMLINE
  1107.       /* *high pass filter output speech  */
  1109.       zerofilt(ahpfo, 2, dhpf1o, &vdecoded[k], l);
  1110.       polefilt(bhpfo, 2, dhpf2o, &vdecoded[k], l);
  1112.       for (j = 0; j < l; j++)
  1113. pf[k + j] = nint(mmax(-32768., mmin(32767., vdecoded[k + j])));
  1115.       /* *write output speech file "ofilehpf"  */
  1117.       if (iodisk(2, &lun[3], strcat(strcpy(tempstr, ofile), "hpf.spd")
  1118.  ,&nrec3, &pf[k], l) != l)
  1119.       {
  1120.         fprintf(stderr, "celp: *** Error writing ofilehpf.spdn");
  1121.         exit(1);
  1122.       }
  1124. #ifdef SUNGRAPH
  1125.       /* *sungraph's output speech file 'ifile_ofile'  */
  1127.       save_sg(ofile_hpf_vid, &pf[k], l, "save ofile_hpf_vid");
  1128. #endif
  1129. #endif
  1131.       k += l;
  1132.     }
  1134.     /* .......................end block................................. */
  1136. #ifdef SUNGRAPH
  1137. #include "sungraph_endblock.h"
  1138. #endif
  1140.     /* *** shift new speech buffer into old speech buffer    */
  1142.     /*           sold    snew  */
  1143.     /*         |-------------------|-------------------| snew  */
  1144.     /*           |-------------------|  */
  1145.     /*    ssub  */
  1147.     for (i = 0; i < ll; i++)
  1148.       sold[i] = snew[i];
  1150.     /* *** frame finished, end loop  */
  1152.   } /* end main while loop; either the analyzer loop, analyzer and       */
  1153.     /* sungraph loop or the synthesizer only loop    */
  1156.   /* ...........e n d  m a i n  l o o p ...............................  */
  1158.   /* *** WRAP-UP ......................................................  */
  1160.   /* *** finished reading & processing "ifile"  */
  1163.   /* *** closing cue and close files  */
  1165.   for (i = 0; i < STREAMBITS; i++)
  1166.     stream[i] = 23456;
  1167.   iodisk(-1, &lun[1], strcat(strcpy(tempstr, ofile), ".spd"),
  1168. &nrec1, pf, l);
  1170. #ifndef STREAMLINE
  1171.   iodisk(-1, &lun[2], strcat(strcpy(tempstr, ofile), "npf.spd"),
  1172. &nrec2, npf, l);
  1173.   iodisk(-1, &lun[3], strcat(strcpy(tempstr, ofile), "hpf.spd"),
  1174. &nrec3, pf, l);
  1175.   fclose(fp25);
  1176. #endif
  1178. #ifdef SUNGRAPH
  1179. #include "sungraph_close.h"
  1181. #else
  1183.   iodisk(-1, &lun[9], ifile, &nrec9, iarf, ll);
  1184. #endif
  1186. #ifndef STREAMLINE
  1188. #ifdef ANALY
  1189.   if (total != 0)
  1190.     realerror = 100. * ((float) error / (float) total);
  1191.   else
  1192.     realerror = 0.0;
  1193.   cliend(sumsnr, framesnr, realerror, sumdm, framedm, sumdm2, framedm2);
  1194. #endif
  1196. #endif
  1198.   exit(0);
  1199. }