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

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

语音压缩

开发平台：

C/C++

cli.c：源码内容
  1. /**************************************************************************
  2. *
  3. * ROUTINE
  4. *               cli
  5. *
  6. * FUNCTION
  7. *               UNIX Command line interface.
  8. * Read and check the UNIX command line.
  9. * Report and log job characteristics and performance.
  10. * 
  11. * SYNOPSIS
  12. * subroutine cli (ifile, ofile, l, ll, lp, np, scale, descale, ber, 
  13. *    +                  mask, stype, eccbits, sbits)
  14. *
  15. *   formal 
  16. *
  17. * data I/O
  18. * name type type function
  19. *       -------------------------------------------------------------------
  20. * ifile char i/o input file name
  21. * ofile char i/o output file name
  22. * l int i/o Code word length
  23. * ll int i/o LPC analysis frame size
  24. * lp int i/o Pitch analysis frame size
  25. * np int i/o Pitch order
  26. * scale float i/o Input speech scaling factor
  27. * descale i i/o Output speech scaling factor
  28. * ber float i/o % bit error rate
  29. * mask int o Error mask
  30. * stype char i/o Spectrum quantizer type
  31. * sbits int i/o Spectrum bit allocation
  32. * eccbits int i/o Error control bits/frame
  33. * ssum int i/o Sum of spectrum bit allocation
  34. *
  35. *   global common 
  36. *                       data    I/O
  37. *       name            type    type    function
  38. *       -------------------------------------------------------------------
  39. * cbgbits int i/o
  40. * frame int i
  41. * ncsize int i/o
  42. * no int i/o
  43. * pbits[] int i/o
  44. * gamma2 float i/o
  45. * ptype[] int i/o
  46. * cbgtype[] int i/o
  47. *
  48. ***************************************************************************
  49. * CELP COMMAND 
  50. *NAME:
  51. *     celp - execute the CELP coder
  52. *
  53. *     The celp command generates a codebook-excited-linear-prediction
  54. *     processed output file from an input file.
  55. *
  56. *SYNOPSIS:
  57. *     celp [-i ifile] [-o ofile] [-p pfile] [-q qfile] [-m mfile] [-l lfile]
  58. *     celp [-c chan]  [-o ofile]
  59. *
  60. *ARGUMENTS:
  61. *     -i      Input file i*2 direct access format (unformatted, consecutive
  62. *             16-bit signed samples).
  63. *             For defaults, see celp.c declaration statements.
  64. * 
  65. *     -o      Speech output file (.spd) i*2 direct access format 
  66. *       (unformatted, consecutive 16-bit signed samples) and
  67. *       bit stream channel file (.chan) hexadecimal format.
  68. *             For defaults, see celp.c declaration statements.
  69. *
  70. *     -p      Parameter file specifying celp characteristics.
  71. *             For defaults, see celp.c declaration statements.
  72. *             Parameters are stored in a ascii text file in the order below
  73. *             with one number per line:
  74. *
  75. *             512 [ncsize = Code book size]
  76. *             60 [l      = Code word length]
  77. *             240 [ll     = LPC analysis frame size]
  78. *             10 [no     = LPC filter order]
  79. *             60 [lp     = Pitch analysis frame size]
  80. *             1         [np     = Pitch order]
  81. *             0.8 [gamma  = Noise weighting factor]
  82. *             1.0 [scale  = Input speech scaling factor]
  83. *       1.0       [descale = Output speech scaling factor]
  84. *       0.0 [ber = % bit error rate]
  85. *       1 [mxsw    = modified excitation logical switch]
  86. *       0.0       [prewt   = prefilter logical switch]
  87. *       hier      [pstype  = type of fractional pitch search]
  88. *
  89. *     -q      Quantization characteristics file.
  90. *             For defaults, see celp.c declaration statements.
  91. *             The file has 3 sections: cbgain, pitch, and spectrum.
  92. *             Each section type is followed by a quantization type,
  93. *             which can be one of the following:  "max", "uniform", "vq",
  94. *             "log", "opt", or "none".  If the quantization type is not 
  95. *       "none",  { the next line is the bit allocation; i.e.:
  96. *
  97. *             cbgain
  98. *             none [unquantized cbgain]
  99. *             pitch
  100. *             max [Max quantization]
  101. *             8 6 5 [8 bit delay, 6 bit delta delay, 5 bit gain]
  102. *             spectrum
  103. *             kang [Kang's quantization]
  104. *             3 4 4 4 4 3 3 3 3 3  [lsp1=3,...,lsp10=3]
  105. *
  106. *     -m      Mask file specifying protected and unprotectected bits
  107. *       in the bit stream when introducing bit errors to the 
  108. *       unpermuted bit stream.  (Note, this protection is separate
  109. *       from the Hamming FEC).  Each line of the mfile corresponds
  110. *       to a bit where each line is a 1 (protected) or 0 (not
  111. *       protected).
  112. *
  113. *     -l      Log file output containing run time information.
  114. *             Defaults to appending to a file called "celp.log".
  115. *             If the file name "none" is specified, no log file
  116. *             is generated.
  117. *
  118. *
  119. *     -c      Input channel file (.chan) hexadecimal format.  Channel
  120. *       files generated from previous analysis runs are used as
  121. *       imputs to a "synthesis only" run.  During this mode, the
  122. *       -i switch is invalid.
  123. *EXAMPLES:
  124. *
  125. *     celp
  126. *             This causes celp to process ifile.spd into ofile.spd (and a
  127. *       nonpostfiltered output in ofilenpf.spd) using the
  128. *             defaults specified by the C declaration statements in
  129. *             celp.c, writes the bit stream file ofile.chan and generates 
  130. *       a log appended to the file "celp.log".  (If SUNGRAPH is 
  131. *       enabled, a set of files, with .sg_data extension, as defined
  132. *       in sungraph_open.com is generated.)
  133. *
  134. *     celp -i speech/dam27 -o dam27.48 -p celp48.p -q celp48.q -l log
  135. *
  136. *             celp processes speech/dam27.spd into the normal, highpassed
  137. *       and nonpostfiltered output, dam27.48.spd, dam27_48hpf.spd
  138. *       and dam27_48npf.spd, respectively, writes the bit stream
  139. *       file dam27_48.chan and appends log information to a file
  140. *       called log.  The celp parameters specified by celp48.p and  
  141. *       quantization characteristics of celp48.q are used.  (If  
  142. *       SUNGRAPH is enabled, a set of files, with .sg_data extension, 
  143. *             as defined in sungraph_open.com is generated.)
  144. *       
  145. *
  146. *     celp -c speech/512_dam27.chan -o 512_dam27b
  147. *
  148. *       celp synthesizes speech/512_dam27.chan channel file into 
  149. *       the normal, highpassed and nonpostfiltered output, 
  150. *       512_dam27b.spd, 512_dam27bhpf.spd and 512_dam27bnpf.spd,
  151. *       respectively.
  152. *
  153. ***************************************************************************
  154. *
  155. * CALLED BY
  156. *
  157. *       celp
  158. *
  159. * CALLS
  160. *
  161. *       
  162. *
  163. **************************************************************************/
  164. #define TRUE            1
  165. #define FALSE           0
  166. #define MAXARG 14
  167. #define MAXTYPE 3
  168. #define MAXQTYPE 5
  169. #include <stdio.h>
  170. #include <sys/time.h>
  171. #include <sys/types.h>
  172. #include <sys/stat.h>
  173. #include <math.h>
  174. #include "ccsub.h"
  175. extern int cbgbits, frame, ncsize, no, pbits[], mxsw;
  176. extern float gamma2, prewt;
  177. extern char ptype[], cbgtype[], pstype[];
  178. static char lfile[82] = "celp.log";
  179. FILE *fp;
  181. cli (ifile,ofile,l,ll,lp,np,scale,descale,ber,mask,stype,sbits,eccbits,ssum,argc,argv)
  182. int *l, *ll, *lp, *np, mask[], sbits[], *eccbits, *ssum, argc;
  183. float *scale, *ber, *descale;
  184. char ifile[], ofile[], stype[], *argv[];
  186. {
  187. /*note:  ncsize, no, and gamma are external variables */
  189.   int psum, rate, bits, rate2, i, j, flag, qflag, iflag, cflag;
  190.   long tim;
  191.   char prog[82], dir[82], host[20], temp[12];
  192.   static char qtype[][10] = {"kang", "log", "max2", "arcsin", "none"},
  193.               pfile[82] = "", qfile[82] = "", mfile[82] = "";
  194.   struct stat statbuf;
  197.   /* *** parse the command line:
  198. celp [-i ifile] [-c chan] [-o ofile] [-p pfile] 
  199.      [-q qfile] [-m mfile] [-l lfile]  */
  201.   if (argc > MAXARG + 1)
  202.   {
  203.     fprintf(stderr,"cli: Too many arguments %dn",argc);
  204.     fprintf(stderr,"%s%sn","celp [-i ifile] [-o ofile] [-p pfile] ",
  205.                             "[-q qfile] [-m mfile] [-l lfile]");
  206.     fprintf(stderr,"%sn","celp [-c chan] [-o ofile]");
  207.   }
  208.     
  209.   if ((argc%2) == 0)
  210.   {
  211.     fprintf(stderr,"cli: Odd number of arguments %dn",argc);
  212.     fprintf(stderr,"%s%sn","celp [-i ifile] [-o ofile] [-p pfile] ",
  213.                             "[-q qfile] [-m mfile] [-l lfile]");
  214.     fprintf(stderr,"%sn","celp [-c chan] [-o ofile]");
  215.     exit(1);
  216.   }
  217.   strcpy(prog, *argv);
  218.   flag = iflag = cflag = FALSE;
  219.   while (--argc > 0)
  220.   {
  221.     if (strncmp("-",*++argv,1) == 0)
  222.     {
  223.       switch (argv[0][1])
  224.       {
  225.         case 'i':
  226.         case 'I':
  227.           if (strncmp("-",*++argv,1) == 0)
  228.           {
  229.             fprintf(stderr,"cli: Missing input filen");
  230.             flag = TRUE;
  231.             --argv;
  232.           }
  233.           else
  234.           {
  235.             strcpy(ifile,*argv);
  236.             --argc;
  237.     iflag = TRUE;
  238.           }
  239.           break;
  240.         case 'o':
  241.         case 'O':
  242.           if (strncmp("-",*++argv,1) == 0)
  243.           {
  244.             fprintf(stderr,"cli: Missing output filen");
  245.             flag = TRUE;
  246.             --argv;
  247.           }
  248.           else
  249.           {
  250.             strcpy(ofile,*argv);
  251.             --argc;
  252.           }
  253.           break;
  254.         case 'p':
  255.         case 'P':
  256.           if (strncmp("-",*++argv,1) == 0)
  257.           {
  258.             fprintf(stderr,"cli: Missing parameter filen");
  259.             flag = TRUE;
  260.             --argv;
  261.           }
  262.           else
  263.           {
  264.             strcpy(pfile,*argv);
  265.             --argc;
  266.           }
  267.           break;
  268.         case 'q':
  269.         case 'Q':
  270.           if (strncmp("-",*++argv,1) == 0)
  271.           {
  272.             fprintf(stderr,"cli: Missing quantization filen");
  273.             flag = TRUE;
  274.             --argv;
  275.           }
  276.           else
  277.           {
  278.             strcpy(qfile,*argv);
  279.             --argc;
  280.           }
  281.           break;
  282.         case 'm':
  283.         case 'M':
  284.           if (strncmp("-",*++argv,1) == 0)
  285.           {
  286.             fprintf(stderr,"cli: Missing mask filen");
  287.             flag = TRUE;
  288.             --argv;
  289.           }
  290.           else
  291.           {
  292.             strcpy(mfile,*argv);
  293.             --argc;
  294.           }
  295.           break;
  296.         case 'l':
  297.         case 'L':
  298.           if (strncmp("-",*++argv,1) == 0)
  299.           {
  300.             fprintf(stderr,"cli: Missing log filen");
  301.             flag = TRUE;
  302.             --argv;
  303.           }
  304.           else
  305.           {
  306.             strcpy(lfile,*argv);
  307.             --argc;
  308.           }
  309.           break;
  310. case 'c':
  311.         case 'C':
  312.           if (strncmp("-",*++argv,1) == 0)
  313.           {
  314.             fprintf(stderr,"cli: Missing channel filen");
  315.             flag = TRUE;
  316.             --argv;
  317.           }
  318.           else
  319.           {
  320.             strcpy(ifile,*argv);
  321.             --argc;
  322.     cflag = TRUE;
  323.           }
  324.           break;
  325.         default:
  326.           printf("cli: Bad switch %sn",*argv);
  327.           flag = TRUE;
  328.       }
  329.     }
  330.     else
  331.     {
  332.       printf("cli: Bad switch %sn",*argv);
  333.       flag = TRUE;
  334.     }
  335.   }
  336.   if (iflag && cflag)
  337.   {
  338.     fprintf(stderr, "%sn", "cli: the -i switch is invalid with the -c switch");
  339.     flag = TRUE;
  340.   }
  341.   if (flag)
  342.   {
  343.     fprintf(stderr,"%s%sn","celp [-i ifile] [-o ofile] [-p pfile] ",
  344.                             "[-q qfile] [-m mfile] [-l lfile]");
  345.     fprintf(stderr,"%sn","celp [-c chan] [-o ofile]");
  346.     exit(1);
  347.   }
  349.   /* *** read input parameter file if requested
  350. (all parameters are required) */
  352.   if (*pfile)
  353.   {
  354.     fp = fopen(pfile,"r");
  355.     if (fp == NULL)
  356.     {
  357.       perror("cli: Error opening the parameter file");
  358.       exit(0);
  359.     }
  360.     fscanf(fp,"%d %d %d %d %d %d %f %f %f %f %d %f %s", &ncsize, l, ll, &no,
  361.            lp, np, &gamma2, scale, descale, ber, &mxsw, &prewt, pstype);
  362.     fclose(fp);
  363.   }
  365.   /* *** read quantization characteristics file if requested
  366. (not all parameters are required) */
  368.   if (*qfile)
  369.   {
  370.     fp = fopen(qfile,"r");
  371.     if (fp == NULL)
  372.     {
  373.       perror("cli: Error opening the quantization characteristics file");
  374.       exit(0);
  375.     }
  376.     while (fscanf(fp,"%s",temp) != EOF)
  377.     {
  378.       if (strcmp(temp,"cbgain") == 0)
  379.       {
  380.         fscanf(fp, "%s", cbgtype);
  381.         if (strcmp(cbgtype, "none"))
  382.           fscanf(fp, "%d", &cbgbits);
  383.       }
  384.       else if (strcmp(temp,"pitch") == 0)
  385.       {
  386.         fscanf(fp, "%s", ptype);
  387.         if (strcmp(ptype, "none"))
  388.           for (i = 0; i < *np + 2; i++)
  389.             fscanf(fp, "%d", &pbits[i]);
  390.       }
  391.       else if (strcmp(temp,"spectrum") == 0)
  392.       {
  393.         fscanf(fp, "%s", stype);
  394.         if (strcmp(ptype, "none") && strcmp(ptype, "opt"))
  395.           for (i = 0; i < no; i++)
  396.             fscanf(fp, "%d", &sbits[i]);
  397.       }
  398.     }
  399.     fclose(fp);
  400.   }
  402.   /* *** calculate data rate if fully quantized */
  404.   /*     (assuming spectrum update rate (ll) = spectrum analysis rate)
  405.     (assuming pitch update rate (lp) = pitch analysis rate)
  406.     (assuming 8khz sampling rate) */
  408.   qflag = FALSE;
  409.   if (strcmp(cbgtype, "none") && strcmp(ptype, "none") &&
  410.       strcmp(stype, "none"))
  411.   {
  412.     qflag = TRUE;
  413.     psum = 2*(pbits[0]+pbits[1]) + 4*(pbits[2]);
  414.     for (*ssum = 0, i = 0; i < no; i++)
  415.       *ssum += sbits[i];
  416.     bits = nint(*ll / (*l) * log10((float)ncsize) / log10(2.) +
  417.            *ll / (*l) * cbgbits + psum + *ssum + *eccbits);
  418.     rate = nint(bits * 8000.0 / (*ll));
  420.     /*    1 bit for sync: */
  422.     rate2 = rate + nint(1.0 * 8000.0 / (*ll));
  423.   }
  425.   /* *** read bit error characteristics file if requested */
  427.   if (*mfile)
  428.   {
  429.     fp = fopen(mfile, "r");
  430.     if (fp == NULL)
  431.     {
  432.       perror("cli: Error opening the bit error characteristics file");
  433.       exit(0);
  434.     }
  435.     for (i = 0; i < bits; i++)
  436.       fscanf(fp, "%1d", mask[i]);
  437.     fclose(fp);
  438.   }    
  440.   /* *** echo out parameters */
  442.   gethostname(host,20);
  443.   stat(prog, &statbuf); 
  444.   getwd(dir);
  445.   time(&tim);
  447.   printf("             User: %s@%sn", getlogin(), host);
  448.   printf("             Time: %s", ctime(&tim));
  449.   printf("          Program: %sn", prog);
  450.   printf("         Modified: %s", ctime(&statbuf.st_mtime));
  451.   printf("        Directory: %sn", dir);
  452.   if (cflag)
  453.   {
  454.     printf("     Channel file: %sn", ifile);
  455.     printf("      Output file: %sn", ofile);
  456.   }
  457.   else
  458.   {
  459.     printf("       Input file: %sn", ifile);
  460.     printf("      Output file: %sn", ofile);
  461.     printf("   Parameter file: %sn", pfile);
  462.     printf("Quantization file: %sn", qfile);
  463.     printf("BER and mask file: %sn", mfile);
  464.     printf("         Log file: %sn", lfile);
  465.     printf("           Code book size (ncsize)=%12dn",ncsize);
  466.     printf("              Code word length (l)=%12dn",*l);
  467.     printf("      LPC analysis frame size (ll)=%12dn",*ll);
  468.     printf("             LPC filter order (no)=%12dn",no);
  469.     printf("    Pitch analysis frame size (lp)=%12dn",*lp);
  470.     printf("         Pitch analysis order (np)=%12dn",*np);
  471.     printf(" Modified Excitation switch (mxsw)=%12dn",mxsw);
  472.     printf("Fractional pitch analysis (pstype)=%12sn",pstype);
  473.     printf("Prefilter weighting factor (prewt)=%12fn",prewt);
  474.     printf("    Noise weighting factor (gamma)=%12fn",gamma2);
  475.     printf("      Input scaling factor (scale)=%12fn",*scale);
  476.     printf("   Output scaling factor (descale)=%12fn",*descale);
  477.     printf("            %% bit error rate (BER)=%12fn",*ber);
  478.     if (strcmp(cbgtype, "none")) 
  479.       printf(" CB Gain: %8s quantizer, bit allocation: %2dn", cbgtype, cbgbits);
  480.     if (strcmp(ptype, "none")) 
  481.     {
  482.       printf("   Pitch: %8s quantizer, bit allocation: ", ptype);
  483.       for (i = 0; i < *np+2; i++)
  484.         printf("%2d",pbits[i]);
  485.       printf("n");
  486.     }
  487.     if (strcmp(stype, "none")) 
  488.     {
  489.       printf("Spectrum: %8s quantizer, bit allocation: ", stype);
  490.       for (i = 0; i < no; i++)
  491.         printf("%2d",sbits[i]);
  492.       printf("n");
  493.     }
  494.     if (qflag) printf("Data rate = %4d bps %3d bpf (%4d bps with 1 bit sync)n",
  495.                     rate, bits, rate2);
  497.     /* *** verify parameters */
  499.     if (ncsize > MAXNCSIZE) 
  500.     {
  501.       fprintf(stderr, "cli:  Error - ncsize too bign");
  502.       exit(1);
  503.     }
  504.     if (*l > MAXL)           
  505.     {
  506.       fprintf(stderr, "cli:  Error - l too bign");
  507.       exit(1);
  508.     }
  509.     if (*ll > MAXLL)         
  510.     {
  511.       fprintf(stderr, "cli:  Error - ll too bign");
  512.       exit(1);
  513.     }
  514.     if (no > MAXNO)         
  515.     {
  516.       fprintf(stderr, "cli:  Error - no too bign");
  517.       exit(1);
  518.     }
  519.     if (*lp > MAXLP)         
  520.     {
  521.       fprintf(stderr, "cli:  Error - lp too bign");
  522.       exit(1);
  523.     }
  524.     if (*np > MAXNP)         
  525.     {
  526.       fprintf(stderr, "cli:  Error - np too bign");
  527.       exit(1);
  528.     }
  529.     if (gamma2 > 1.0)        
  530.     {
  531.       fprintf(stderr, "cli:  Error - gamma > 1n");
  532.       exit(1);
  533.     }
  534.     if (*scale < 0.0)        
  535.     {
  536.       fprintf(stderr, "cli:  Error - scale < 0n");
  537.       exit(1);
  538.     }
  539.     if (*ber < 0.0)     
  540.     {
  541.       fprintf(stderr, "cli:  Error - ber < 0n");
  542.       exit(1);
  543.     }
  544.     if (*ll%*l) 
  545.     {
  546.       fprintf(stderr, "cli:  *** Error - ll & l are inconsistentn");
  547.       exit(1);
  548.     }
  549.     if (*ll%*lp) 
  550.     {
  551.       fprintf(stderr, "cli:  *** Error - ll & lp are inconsistentn");
  552.       exit(1);
  553.     }
  554.     if (cbgbits < 5 || cbgbits > 7) 
  555.     {
  556.       fprintf(stderr, "cli:  Error - bad cbgbits (not implemented)n");
  557.       exit(1);
  558.     }
  559.     if (pbits[0] > 8) 
  560.     {
  561.       fprintf(stderr, "cli:  *** Error - bad pbits[0] (not implemented)n");
  562.       exit(1);
  563.     }
  564.     if (pbits[1] > 7 || pbits[1] < 3) 
  565.     {
  566.       fprintf(stderr, "cli:  *** Error - bad pbits[1] (not implemented)n");
  567.       exit(1);
  568.     }
  569.     for (i = 2; i < *np+2; i++)
  570.     {
  571.       if (pbits[i]  <  3 || pbits[i] > 5)    
  572.       {
  573.         fprintf(stderr, "cli:  *** Error - bad pbits (not implemented)n");
  574.         exit(1);
  575.       }
  576.     }
  577.     flag = TRUE;
  578.     for (j = 0; j < MAXQTYPE; j++)
  579.     {
  580.       if (strcmp(cbgtype, qtype[j]) == 0) flag = FALSE;
  581.     }
  582.     if (flag) 
  583.     {
  584.       fprintf(stderr, "cli:  *** Error - bad cbgain quantizer typen");
  585.       exit(1);
  586.     }
  587.     flag = TRUE;
  588.     for (j = 0; j < MAXQTYPE; j++)
  589.     {
  590.       if (strcmp(ptype, qtype[j]) == 0) flag = FALSE;
  591.     }
  592.     if (flag) 
  593.     {
  594.       fprintf(stderr, "cli:  *** Error - bad pitch quantizer typen");
  595.       exit(1);
  596.     }
  597.     flag = TRUE;
  598.     for (j = 0; j < MAXQTYPE; j++)
  599.     {
  600.       if (strcmp(stype, qtype[j]) == 0) flag = FALSE;
  601.     }
  602.     if (flag) 
  603.     {
  604.       fprintf(stderr, "cli:  *** Error - bad spectrum quantizer typen");
  605.       exit(1);
  606.     }
  608.     /* *** generate log file if requested */
  610.     if (strcmp(lfile, "none"))
  611.     {  
  612.       if (strcmp(lfile, "celp.log") == 0)
  613.       {
  614.         fp = fopen(lfile, "a");
  615.         if (fp == NULL)
  616.         {
  617.           perror("cli: Error opening the log file");
  618.           exit(0);
  619.         }
  620.       }
  621.       else
  622.       {
  623.         fp = fopen(lfile, "w");
  624.         if (fp == NULL)
  625.         {
  626.           perror("cli: Error opening the log file");
  627.           exit(0);
  628.         }
  629.       }
  630.       fprintf(fp, "             User: %s@%sn", getlogin(), host);
  631.       fprintf(fp, "             Time: %s", ctime(&tim));
  632.       fprintf(fp, "          Program: %sn", prog);
  633.       fprintf(fp, "         Modified: %s", ctime(&statbuf.st_mtime));
  634.       fprintf(fp, "        Directory: %sn", dir);
  635.       fprintf(fp, "       Input file: %sn", ifile);
  636.       fprintf(fp, "      Output file: %sn", ofile);
  637.       fprintf(fp, "   Parameter file: %sn", pfile);
  638.       fprintf(fp, "Quantization file: %sn", qfile);
  639.       fprintf(fp, "BER and mask file: %sn", mfile);
  640.       fprintf(fp, "         Log file: %sn", lfile);
  641.       fprintf(fp, "           Code book size (ncsize)=%12dn",ncsize);
  642.       fprintf(fp, "              Code word length (l)=%12dn",*l);
  643.       fprintf(fp, "      LPC analysis frame size (ll)=%12dn",*ll);
  644.       fprintf(fp, "             LPC filter order (no)=%12dn",no);
  645.       fprintf(fp, "    Pitch analysis frame size (lp)=%12dn",*lp);
  646.       fprintf(fp, "         Pitch analysis order (np)=%12dn",*np);
  647.       fprintf(fp, " Modified Excitation switch (mxsw)=%12dn",mxsw);
  648.       fprintf(fp, "Fractional pitch analysis (pstype)=%12sn",pstype);
  649.       fprintf(fp, "Prefilter weighting factor (prewt)=%12fn",prewt);      
  650.       fprintf(fp, "    Noise weighting factor (gamma)=%12fn",gamma2);
  651.       fprintf(fp, "      Input scaling factor (scale)=%12fn",*scale);
  652.       fprintf(fp, "   Output scaling factor (descale)=%12fn",*descale);
  653.       fprintf(fp, "            %% bit error rate (BER)=%12fn",*ber);
  654.       if (strcmp(cbgtype, "none")) 
  655.         fprintf(fp, " CB Gain: %8s quantizer, bit allocation: %2dn",
  656.                    cbgtype, cbgbits);
  657.       if (strcmp(ptype, "none")) 
  658.       {
  659.         fprintf(fp, "   Pitch: %8s quantizer, bit allocation: ", ptype);
  660.         for (i = 0; i < *np+2; i++)
  661.           fprintf(fp, "%2d",pbits[i]);
  662.         fprintf(fp, "n");
  663.       }
  664.       if (strcmp(stype, "none")) 
  665.       {
  666.         fprintf(fp, "Spectrum: %8s quantizer, bit allocation: ", stype);
  667.         for (i = 0; i < no; i++)
  668.           fprintf(fp, "%2d",sbits[i]);
  669.         fprintf(fp, "n");
  670.       }
  671.       if (qflag)
  672.         fprintf(fp, "Data rate = %4d bps %3d bpf (%4d bps with 1 bit sync)n",
  673.                   rate, bits, rate2);
  674.     }
  675.   }
  676. }
  677. /**************************************************************************
  678. *
  679. * ROUTINE
  680. *               cliend
  681. *
  682. * FUNCTION
  683. *               End of command line interface entry.
  684. * Report and log job characteristics and performance.
  685. * 
  686. * SYNOPSIS
  687. *
  688. * entry cliend(sumsnr, framesnr, realerror,
  689. *     &             sumdm, framedm, sumdm2, framedm2)
  690. *
  691. *   formal 
  692. *
  693. * data I/O
  694. * name type type function
  695. *       ------------------------------------------------------------------
  696. * sumsnr float i sum of segmental signal-to-noise
  697. * framesnr int i count of frames used for snr sum
  698. * realerror float i bit error rate
  699. * sumdm float i sum of speech distortion measures
  700. * (see dist.c)
  701. * framedm int i count of frames used for sumdm
  702. * sumdm2 float i sum of spectral distortion measures
  703. * (see dist.c)
  704. * framedm2 int i count of frames used for sumdm2
  705. *
  706. **************************************************************************/
  707. #include <sys/times.h>
  708. cliend(sumsnr, framesnr, realerror, sumdm, framedm, sumdm2, framedm2)
  709. int framesnr, framedm, framedm2;
  710. float sumsnr, realerror, sumdm[], sumdm2[];
  711. {
  712.   long tim;
  713.   struct tms buffer;
  714.   /* *calculate run time, print time & date */
  715.   
  716.   time(&tim);
  717.   times(&buffer);
  718.   printf("Finished processing %d frames of data on %s", frame, ctime(&tim));
  720.   /* *actual bit error rate */
  721.   
  722.   printf("Overall bit error rate = %8.4f%%n", realerror);
  724.   /* *average segmental signal-to-noise */
  725.   
  726.   if (framesnr <= 0) framesnr = 1;
  727.   if (sumsnr / framesnr > 0.0)
  728.     printf("Segmental SNR = %8.4f dB (%d subframes averaged for SNR)n",
  729.            10 * log10(sumsnr/framesnr),framesnr);
  730.   else 
  731.     printf("Segmental SNR = %8.4f    (%d subframes averaged for SNR)n",
  732.            sumsnr/framesnr,framesnr);
  734.   /* *speech distortion */
  735.   
  736.   if (framedm != 0.0)
  737.   {
  738.     printf("Speech distortion:n");
  739.     printf("likelihood measures   %7.4f     %7.4fn",
  740.            sumdm[0]/framedm,sumdm[1]/framedm);
  741.     printf("cosh measures         %7.4f dB, %7.4f dB, %7.4f dB, %7.4f dBn",
  742.            sumdm[2]/framedm, sumdm[3]/framedm,
  743.            sumdm[4]/framedm, sumdm[5]/framedm);
  744.     printf("cepstral distance     %7.4f dB, %7.4f dB, %7.4f dBn",
  745.            sumdm[6]/framedm,sumdm[7]/framedm,sumdm[8]/framedm);
  746.     printf("average distance      %7.4f dBn", sumdm[9]/framedm);
  747.   }
  748.   printf("%d subframes averaged for distance measuresn", framedm);
  750.   /* *spectral distortion */
  751.   
  752.   if (framedm2 != 0.0)
  753.   {
  754.     printf("Spectral distortion:n");
  755.     printf("likelihood measures   %7.4f     %7.4fn",
  756.            sumdm2[0]/framedm2,sumdm2[1]/framedm2);
  757.     printf("cosh measures         %7.4f dB, %7.4f dB, %7.4f dB, %7.4f dBn",
  758.            sumdm2[2]/framedm2, sumdm2[3]/framedm2,
  759.            sumdm2[4]/framedm2, sumdm2[5]/framedm2);
  760.     printf("cepstral distance     %7.4f dB, %7.4f dB, %7.4f dBn",
  761.            sumdm2[6]/framedm2,sumdm2[7]/framedm2,sumdm2[8]/framedm2);
  762.     printf("average distance      %7.4f dBn", sumdm2[9]/framedm2);
  763.   }
  764.   printf("%d subframes averaged for distance measuresn", framedm2);
  765.   
  766.   /* *print runtime, etc. (& ring bell) */
  767.   
  768.   printf("Elapsed times (s):  %.1f user, %.1f system, %.1f total7n",
  769.           buffer.tms_utime/60., buffer.tms_stime/60.,
  770.           (buffer.tms_utime + buffer.tms_stime)/60.);
  772.   /* *write above to log file */
  773.   
  774.   if (strcmp(lfile, "none"))
  775.   {
  776.     fprintf(fp, "Finished processing %d frames of data on %s",
  777.                  frame, ctime(&tim));
  779.     fprintf(fp, "Overall bit error rate = %8.4f%%n", realerror);
  781.     if (sumsnr/framesnr > 0.0)
  782.       fprintf(fp, "Segmental SNR = %8.4f dB (%d subframes averaged for SNR)n",
  783.                    10 * log10(sumsnr/framesnr), framesnr);
  784.     else 
  785.       fprintf(fp, "Segmental SNR = %8.4f    (%d subframes averaged for SNR)n",
  786.                    sumsnr/framesnr, framesnr);
  788.     if (framedm != 0.0)
  789.     {
  790.       fprintf(fp, "Speech distortion:n");
  791.       fprintf(fp, "likelihood measures %7.4f     %7.4fn",
  792.                  sumdm[0]/framedm,sumdm[1]/framedm);
  793.       fprintf(fp, "cosh measures       %7.4f dB, %7.4f dB, %7.4f dB, %7.4f dBn",
  794.                  sumdm[2]/framedm, sumdm[3]/framedm,
  795.                  sumdm[4]/framedm, sumdm[5]/framedm);
  796.       fprintf(fp, "cepstral distance   %7.4f dB, %7.4f dB, %7.4f dBn",
  797.                  sumdm[6]/framedm,sumdm[7]/framedm,sumdm[8]/framedm);
  798.       fprintf(fp, "average distance    %7.4f dBn", sumdm[9]/framedm);
  799.     }
  801.     fprintf(fp, "%d subframes averaged for distance measuresn", framedm);
  803.     if (framedm2 != 0.0)
  804.     {
  805.       fprintf(fp, "Spectral distortion:n");
  806.       fprintf(fp, "likelihood measures   %7.4f     %7.4fn",
  807.                  sumdm2[0]/framedm2,sumdm2[1]/framedm2);
  808.       fprintf(fp, "cosh measures       %7.4f dB, %7.4f dB, %7.4f dB, %7.4f dBn",
  809.                  sumdm2[2]/framedm2, sumdm2[3]/framedm2,
  810.                  sumdm2[4]/framedm2, sumdm2[5]/framedm2);
  811.       fprintf(fp, "cepstral distance   %7.4f dB, %7.4f dB, %7.4f dBn",
  812.                  sumdm2[6]/framedm2,sumdm2[7]/framedm2,sumdm2[8]/framedm2);
  813.       fprintf(fp, "average distance    %7.4f dBn", sumdm2[9]/framedm2);
  814.     }
  816.     fprintf(fp, "%d subframes averaged for distance measuresn", framedm2);
  818.     fprintf(fp, "Elapsed times (s):  %f user, %f system, %f total6n",
  819.                  buffer.tms_utime/60., buffer.tms_stime/60.,
  820.                  (buffer.tms_utime + buffer.tms_stime)/60.);
  821.     fprintf(fp, "%s%sn","...................................",
  822.                          "...................................");
  823.     fclose(fp);
  824.   }
  826. }