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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 语音压缩 > 查看源码
melp_sub.c
资源名称：1.8kbpsMELP.rar　[点击查看]
上传用户：luckfish
上传日期：2021-12-16
资源大小：77k
文件大小：14k
源码类别：

语音压缩

开发平台：

Visual C++

melp_sub.c：源码内容
  1. /*
  3. 2.4 kbps MELP Proposed Federal Standard speech coder
  5. version 1.2
  7. Copyright (c) 1996, Texas Instruments, Inc.  
  9. Texas Instruments has intellectual property rights on the MELP
  10. algorithm.  The Texas Instruments contact for licensing issues for
  11. commercial and non-government use is William Gordon, Director,
  12. Government Contracts, Texas Instruments Incorporated, Semiconductor
  13. Group (phone 972 480 7442).
  16. */
  18. /*
  20.   melp_sub.c: MELP-specific subroutines
  22. */
  24. #include <stdio.h>
  25. #include <math.h>
  26. #include "spbstd.h"
  27. #include "mat.h"
  28. #include "melp_sub.h"
  29. #include "dsp_sub.h"
  30. #include "pit.h"
  32. /*
  33.     Name: bpvc_ana.c
  34.     Description: Bandpass voicing analysis
  35.     Inputs:
  36.       speech[] - input speech signal
  37.       fpitch[] - initial (floating point) pitch estimates
  38.     Outputs: 
  39.       bpvc[] - bandpass voicing decisions
  40.       pitch[] - frame pitch estimates
  41.     Returns: void 
  43.     Copyright (c) 1995 by Texas Instruments, Inc.  All rights reserved.
  44. */
  46. /* Filter orders */
  47. #define ENV_ORD 2
  48. #define BPF_ORD 6
  50. /* Constants */
  51. static int PITCHMAX;
  52. static int PITCHMIN;
  53. static int FRAME;
  54. static int NUM_BANDS;
  55. static int PIT_BEG;
  56. static int PIT_P_FR;
  57. static int PIT_FR_BEG;
  58. static int FIRST_CNTR;
  59. static int BPF_BEG;
  60. static int NUM_PITCHES;
  61. static int LMIN;
  63. /* Static memory */
  64. static float **bpfdel;
  65. static float **envdel;
  66. static float *envdel2;
  67. static float *sigbuf;
  69. /* External variables */
  70. extern float bpf_num[], bpf_den[];
  72. void bpvc_ana(float speech[], float fpitch[], float bpvc[], float pitch[])
  73. {
  75.     float pcorr, temp;
  76.     int j;
  78.     /* Filter lowest band and estimate pitch */
  79.     v_equ(&sigbuf[PIT_BEG-BPF_ORD],&bpfdel[0][0],BPF_ORD);
  80.     polflt(&speech[PIT_FR_BEG],&bpf_den[0],&sigbuf[PIT_BEG],
  81.    BPF_ORD,PIT_P_FR);
  82.     v_equ(&bpfdel[0][0],&sigbuf[PIT_BEG+FRAME-BPF_ORD],BPF_ORD);
  83.     zerflt(&sigbuf[PIT_BEG],&bpf_num[0],&sigbuf[PIT_BEG],
  84.    BPF_ORD,PIT_P_FR);
  85.     
  86.     *pitch = frac_pch(&sigbuf[FIRST_CNTR],
  87. &bpvc[0],fpitch[0],5,PITCHMIN,PITCHMAX,LMIN);
  88.     
  89.     for (j = 1; j < NUM_PITCHES; j++) {
  90. temp = frac_pch(&sigbuf[FIRST_CNTR],
  91. &pcorr,fpitch[j],5,PITCHMIN,PITCHMAX,LMIN);
  93. /* choose largest correlation value */
  94. if (pcorr > bpvc[0]) {
  95.     *pitch = temp;
  96.     bpvc[0] = pcorr; 
  97. }
  99.     }
  100.     
  101.     /* Calculate bandpass voicing for frames */
  102.     
  103.     for (j = 1; j < NUM_BANDS; j++) {
  105. /* Bandpass filter input speech */
  106. v_equ(&sigbuf[PIT_BEG-BPF_ORD],&bpfdel[j][0],BPF_ORD);
  107. polflt(&speech[PIT_FR_BEG],&bpf_den[j*(BPF_ORD+1)],&sigbuf[PIT_BEG],
  108.        BPF_ORD,PIT_P_FR);
  109. v_equ(&bpfdel[j][0],&sigbuf[PIT_BEG+FRAME-BPF_ORD],BPF_ORD);
  110. zerflt(&sigbuf[PIT_BEG],&bpf_num[j*(BPF_ORD+1)],&sigbuf[PIT_BEG],
  111.        BPF_ORD,PIT_P_FR);
  113. /* Check correlations for each frame */
  114. temp = frac_pch(&sigbuf[FIRST_CNTR],
  115. &bpvc[j],*pitch,0,PITCHMIN,PITCHMAX,LMIN);
  117. /* Calculate envelope of bandpass filtered input speech */
  118. temp = envdel2[j];
  119. envdel2[j] = sigbuf[PIT_BEG+FRAME-1];
  120. v_equ(&sigbuf[PIT_BEG-ENV_ORD],&envdel[j][0],ENV_ORD);
  121. envelope(&sigbuf[PIT_BEG],temp,&sigbuf[PIT_BEG],PIT_P_FR);
  122. v_equ(&envdel[j][0],&sigbuf[PIT_BEG+FRAME-ENV_ORD],ENV_ORD);
  124. /* Check correlations for each frame */
  125. temp = frac_pch(&sigbuf[FIRST_CNTR],&pcorr,
  126. *pitch,0,PITCHMIN,PITCHMAX,LMIN);
  128. /* reduce envelope correlation */
  129. pcorr -= 0.1;
  131. if (pcorr > bpvc[j])
  132.     bpvc[j] = pcorr;
  133.     }
  134. }
  136. void bpvc_ana_init(int fr, int pmin, int pmax, int nbands, int num_p, int lmin)
  137. {
  139.     /* Initialize constants */
  140.     FRAME = fr;
  141.     PITCHMIN = pmin;
  142.     PITCHMAX = pmax;
  143.     NUM_BANDS = nbands;
  144.     NUM_PITCHES = num_p;
  145.     LMIN = lmin;
  146.     PIT_BEG = BPF_ORD;
  147.     PIT_P_FR = ((2*PITCHMAX)+1);
  148.     PIT_FR_BEG = (-PITCHMAX);
  149.     FIRST_CNTR = (PIT_BEG+PITCHMAX);
  150.     BPF_BEG = (PIT_BEG+PIT_P_FR-FRAME);
  152.     /* Allocate memory */
  153.     MEM_2ALLOC(malloc,bpfdel,NUM_BANDS,BPF_ORD,float);
  154.     v_zap(&bpfdel[0][0],NUM_BANDS*BPF_ORD);
  156.     MEM_2ALLOC(malloc,envdel,NUM_BANDS,ENV_ORD,float);
  157.     v_zap(&envdel[0][0],NUM_BANDS*ENV_ORD);
  158.     MEM_ALLOC(malloc,envdel2,NUM_BANDS,float);
  159.     v_zap(envdel2,NUM_BANDS);
  161.     /* Allocate scratch buffer */
  162.     MEM_ALLOC(malloc,sigbuf,PIT_BEG+PIT_P_FR,float);
  163. }
  165. /*
  166.     Name: dc_rmv.c
  167.     Description: remove DC from input signal
  168.     Inputs: 
  169.       sigin[] - input signal
  170.       dcdel[] - filter delay history (size DC_ORD)
  171.       frame - number of samples to filter
  172.     Outputs: 
  173.       sigout[] - output signal
  174.       dcdel[] - updated filter delay history
  175.     Returns: void 
  176.     See_Also:
  178.     Copyright (c) 1995 by Texas Instruments, Inc.  All rights reserved.
  179. */
  181. /* Filter order */
  182. #define DC_ORD 4
  184. /* DC removal filter */
  185. /* 4th order Chebychev Type II 60 Hz removal filter */
  186. /* cutoff=60 Hz, stop=-30 dB */
  187. static float dc_num[DC_ORD+1] = {    
  188.       0.92692416,
  189.      -3.70563834,
  190.       5.55742893,
  191.      -3.70563834,
  192.       0.92692416};
  193. static float dc_den[DC_ORD+1] = {
  194.        1.00000000,
  195.      -3.84610723,
  196.       5.55209760,
  197.      -3.56516069,
  198.       0.85918839};
  200. void dc_rmv(float sigin[], float sigout[], float dcdel[], int frame)
  201. {
  202.     float *sigbuf;
  204.     /* Allocate scratch buffer */
  205.     MEM_ALLOC(malloc,sigbuf,frame+DC_ORD,float);
  207.     /* Remove DC from input speech */
  208.     v_equ(sigbuf,dcdel,DC_ORD);
  209.     polflt(sigin,dc_den,&sigbuf[DC_ORD],DC_ORD,frame);
  210.     v_equ(dcdel,&sigbuf[frame],DC_ORD);
  211.     zerflt(&sigbuf[DC_ORD],dc_num,sigout,DC_ORD,frame);
  213.     /* Free scratch buffer */
  214.     MEM_FREE(free,sigbuf);
  216. }
  218. /*
  219.     Name: gain_ana.c
  220.     Description: analyze gain level for input signal
  221.     Inputs: 
  222.       sigin[] - input signal
  223.       pitch - pitch value (for pitch synchronous window)
  224.       minlength - minimum window length
  225.       maxlength - maximum window length
  226.     Outputs: 
  227.     Returns: log gain in dB
  228.     See_Also:
  230.     Copyright (c) 1995 by Texas Instruments, Inc.  All rights reserved.
  231. */
  233. #define MINGAIN 0.0
  235. float gain_ana(float sigin[], float pitch, int minlength, int maxlength)
  236. {
  237.     int length;
  238.     float flength, gain;
  240.     /* Find shortest pitch multiple window length (floating point) */
  241.     flength = pitch;
  242.     while (flength < minlength)
  243.       flength += pitch;
  245.     /* Convert window length to integer and check against maximum */
  246.     length = flength + 0.5;
  247.     if (length > maxlength)
  248.       length = (length/2);
  249.     
  250.     /* Calculate RMS gain in dB */
  251.     gain = 10.0*log10(0.01 + (v_magsq(&sigin[-(length/2)],length) / length));
  252.     if (gain < MINGAIN)
  253.       gain = MINGAIN;
  255.     return(gain);
  257. }
  259. /*
  260.     Name: lin_int_bnd.c
  261.     Description: Linear interpolation within bounds
  262.     Inputs:
  263.       x - input X value
  264.       xmin - minimum X value
  265.       xmax - maximum X value
  266.       ymin - minimum Y value
  267.       ymax - maximum Y value
  268.     Returns: y - interpolated and bounded y value
  270.     Copyright (c) 1995 by Texas Instruments, Inc.  All rights reserved.
  271. */
  273. float lin_int_bnd(float x,float xmin,float xmax,float ymin,float ymax)
  275. {
  276.     float y;
  278.     if (x <= xmin)
  279.       y = ymin;
  281.     else if (x >= xmax)
  282.       y = ymax;
  284.     else 
  285.       y = ymin + (x-xmin)*(ymax-ymin)/(xmax-xmin);
  287.     return(y);
  288. }
  290. /*
  291.     Name: noise_est.c
  292.     Description: Estimate long-term noise floor
  293.     Inputs:
  294.       gain - input gain (in dB)
  295.       noise_gain - current noise gain estimate
  296.       up - maximum up stepsize
  297.       down - maximum down stepsize
  298.       min - minimum allowed gain
  299.       max - maximum allowed gain
  300.     Outputs:
  301.       noise_gain - updated noise gain estimate
  302.     Returns: void
  304.     Copyright (c) 1995 by Texas Instruments, Inc.  All rights reserved.
  305. */
  307. void noise_est(float gain,float *noise_gain,float up,float down,float min,float max)
  309. {
  311.     /* Update noise_gain */
  312.     if (gain > *noise_gain+up)
  313.       *noise_gain = *noise_gain+up;
  315.     else if (gain < *noise_gain+down)
  316.       *noise_gain = *noise_gain+down;
  318.     else
  319.       *noise_gain = gain;
  321.     /* Constrain total range of noise_gain */
  322.     if (*noise_gain < min)
  323.       *noise_gain = min;
  324.     if (*noise_gain > max)
  325.       *noise_gain = max;
  327. }
  329. /*
  330.     Name: noise_sup.c
  331.     Description: Perform noise suppression on speech gain
  332.     Inputs: (all in dB)
  333.       gain - input gain (in dB)
  334.       noise_gain - current noise gain estimate (in dB)
  335.       max_noise - maximum allowed noise gain 
  336.       max_atten - maximum allowed attenuation
  337.       nfact - noise floor boost
  338.     Outputs:
  339.       gain - updated gain 
  340.     Returns: void
  342.     Copyright (c) 1995 by Texas Instruments, Inc.  All rights reserved.
  343. */
  345. void noise_sup(float *gain,float noise_gain,float max_noise,float max_atten,float nfact)
  347. {
  348.     float gain_lev,suppress;
  350.     /* Reduce effect for louder background noise */
  351.     if (noise_gain > max_noise)
  352.       noise_gain = max_noise;
  354.     /* Calculate suppression factor */
  355.     gain_lev = *gain - (noise_gain + nfact);
  356.     if (gain_lev > 0.001) {
  357. suppress = -10.0*log10(1.0 - pow(10.0,-0.1*gain_lev));
  358. if (suppress > max_atten)
  359.   suppress = max_atten;
  360.     }
  361.     else
  362.       suppress = max_atten;
  364.     /* Apply suppression to input gain */
  365.     *gain -= suppress;
  367. }
  369. /*
  370.     Name: q_bpvc.c, q_bpvc_dec.c
  371.     Description: Quantize/decode bandpass voicing
  372.     Inputs:
  373.       bpvc, bpvc_index
  374.       bpthresh - threshold
  375.       NUM_BANDS - number of bands
  376.     Outputs: 
  377.       bpvc, bpvc_index
  378.     Returns: uv_flag - flag if unvoiced
  380.     Copyright (c) 1995 by Texas Instruments, Inc.  All rights reserved.
  381. */
  383. /* Compile constants */
  384. #define INVALID_BPVC 0001
  386. int q_bpvc(float *bpvc,int *bpvc_index,float bpthresh,int NUM_BANDS)
  388. {
  389.     int j, uv_flag;
  391.     uv_flag = 1;
  393.     if (bpvc[0] > bpthresh) {
  395. /* Voiced: pack bandpass voicing */
  396. uv_flag = 0;
  397. *bpvc_index = 0;
  398. bpvc[0] = 1.0;
  400. for (j = 1; j < NUM_BANDS; j++) {
  401.     *bpvc_index <<= 1; /* left shift */
  402.     if (bpvc[j] > bpthresh) {
  403. bpvc[j] = 1.0;
  404. *bpvc_index |= 1;
  405.     }
  406.     else {
  407. bpvc[j] = 0.0;
  408. *bpvc_index |= 0;
  409.     }
  410. }
  412. /* Don't use invalid code (only top band voiced) */
  413. if (*bpvc_index == INVALID_BPVC) {
  414.     bpvc[(NUM_BANDS-1)] = 0.0;
  415.     *bpvc_index = 0;
  416. }
  417.     }
  418.     
  419.     else {
  421. /* Unvoiced: force all bands unvoiced */
  422. *bpvc_index = 0;
  423. for (j = 0; j < NUM_BANDS; j++)
  424.     bpvc[j] = 0.0;
  425.     }
  427.     return(uv_flag);
  428. }
  430. void q_bpvc_dec(float *bpvc,int *bpvc_index,int uv_flag,int NUM_BANDS)
  432. {
  433.     int j;
  435.     if (uv_flag) {
  437. /* Unvoiced: set all bpvc to 0 */
  438. *bpvc_index = 0;
  439. bpvc[0] = 0.0;
  440.     }
  441.     
  442.     else {
  444. /* Voiced: set bpvc[0] to 1.0 */
  445. bpvc[0] = 1.0;
  446.     }
  447.     
  448.     if (*bpvc_index == INVALID_BPVC) {
  450. /* Invalid code received: set higher band voicing to zero */
  451. *bpvc_index = 0;
  452.     }
  454.     /* Decode remaining bands */
  455.     for (j = NUM_BANDS-1; j > 0; j--) {
  456. if ((*bpvc_index & 1) == 1)
  457.     bpvc[j] = 1.0;
  458. else
  459.     bpvc[j] = 0.0;
  460. *bpvc_index >>= 1;
  461.     }
  462. }
  464. /*
  465.     Name: q_gain.c, q_gain_dec.c
  466.     Description: Quantize/decode two gain terms using quasi-differential coding
  467.     Inputs:
  468.       gain[2],gain_index[2]
  469.       GN_QLO,GN_QUP,GN_QLEV for second gain term
  470.     Outputs: 
  471.       gain[2],gain_index[2]
  472.     Returns: void
  474.     Copyright (c) 1995 by Texas Instruments, Inc.  All rights reserved.
  475. */
  477. /* Compile constants */
  478. #define GAIN_INT_DB 5.0
  480. void q_gain(float *gain,int *gain_index,float GN_QLO,float GN_QUP,float GN_QLEV)
  482. {
  483.     static float prev_gain = 0.0;
  484.     float temp,temp2;
  486.     /* Quantize second gain term with uniform quantizer */
  487.     quant_u(&gain[1],&gain_index[1],GN_QLO,GN_QUP,GN_QLEV);
  488.     
  489.     /* Check for intermediate gain interpolation */
  490.     if (gain[0] < GN_QLO)
  491.       gain[0] = GN_QLO;
  492.     if (gain[0] > GN_QUP)
  493.       gain[0] = GN_QUP;
  494.     if (fabs(gain[1] - prev_gain) < GAIN_INT_DB && 
  495. fabs(gain[0] - 0.5*(gain[1]+prev_gain)) < 3.0) {
  497. /* interpolate and set special code */
  498. gain[0] = 0.5*(gain[1]+prev_gain);
  499. gain_index[0] = 0;
  500.     }
  501.     else {
  503. /* Code intermediate gain with 7-levels */
  504. if (prev_gain < gain[1]) {
  505.     temp = prev_gain;
  506.     temp2 = gain[1];
  507. }
  508. else {
  509.     temp = gain[1];
  510.     temp2 = prev_gain;
  511. }
  512. temp -= 6.0;
  513. temp2 += 6.0;
  514. if (temp < GN_QLO)
  515.   temp = GN_QLO;
  516. if (temp2 > GN_QUP)
  517.   temp2 = GN_QUP;
  518. quant_u(&gain[0],&gain_index[0],temp,temp2,7);
  520. /* Skip all-zero code */
  521. gain_index[0]++;
  522.     }
  524.     /* Update previous gain for next time */
  525.     prev_gain = gain[1];
  526.     
  527. }
  529. void q_gain_dec(float *gain,int *gain_index,float GN_QLO,float GN_QUP,float GN_QLEV)
  530. {
  532.     static float prev_gain = 0.0;
  533.     static int prev_gain_err = 0;
  534.     float temp,temp2;
  536.     /* Decode second gain term */
  537.     quant_u_dec(gain_index[1],&gain[1],GN_QLO,GN_QUP,GN_QLEV);
  538.     
  539.     if (gain_index[0] == 0) {
  541. /* interpolation bit code for intermediate gain */
  542. if (fabs(gain[1] - prev_gain) > GAIN_INT_DB) {
  543.     /* Invalid received data (bit error) */
  544.     if (prev_gain_err == 0) {
  545. /* First time: don't allow gain excursion */
  546. gain[1] = prev_gain;
  547.     }
  548.     prev_gain_err = 1;
  549. }
  550. else 
  551.   prev_gain_err = 0;
  553. /* Use interpolated gain value */
  554. gain[0] = 0.5*(gain[1]+prev_gain);
  555.     }
  557.     else {
  559. /* Decode 7-bit quantizer for first gain term */
  560. prev_gain_err = 0;
  561. gain_index[0]--;
  562. if (prev_gain < gain[1]) {
  563.     temp = prev_gain;
  564.     temp2 = gain[1];
  565. }
  566. else {
  567.     temp = gain[1];
  568.     temp2 = prev_gain;
  569. }
  570. temp -= 6.0;
  571. temp2 += 6.0;
  572. if (temp < GN_QLO)
  573.   temp = GN_QLO;
  574. if (temp2 > GN_QUP)
  575.   temp2 = GN_QUP;
  576. quant_u_dec(gain_index[0],&gain[0],temp,temp2,7);
  577.     }
  579.     /* Update previous gain for next time */
  580.     prev_gain = gain[1];
  581.     
  582. }
  584. /*
  585.     Name: scale_adj.c
  586.     Description: Adjust scaling of output speech signal.
  587.     Inputs:
  588.       speech - speech signal
  589.       gain - desired RMS gain
  590.       prev_scale - previous scale factor
  591.       length - number of samples in signal
  592.       SCALEOVER - number of points to interpolate scale factor
  593.     Warning: SCALEOVER is assumed to be less than length.
  594.     Outputs: 
  595.       speech - scaled speech signal
  596.       prev_scale - updated previous scale factor
  597.     Returns: void
  599.     Copyright (c) 1995 by Texas Instruments, Inc.  All rights reserved.
  600. */
  602. void scale_adj(float *speech, float gain, float *prev_scale, int length, int SCALEOVER)
  604. {
  605.     int i;
  606.     float scale;
  608.     /* Calculate desired scaling factor to match gain level */
  609.     scale = gain / (sqrt(v_magsq(&speech[0],length) / length) + .01);
  611.     /* interpolate scale factors for first SCALEOVER points */
  612.     for (i = 1; i < SCALEOVER; i++) {
  613. speech[i-1] *= ((scale*i + *prev_scale*(SCALEOVER-i))
  614.       * (1.0/SCALEOVER) );
  615.     }
  616.     
  617.     /* Scale rest of signal */
  618.     v_scale(&speech[SCALEOVER-1],scale,length-SCALEOVER+1);
  620.     /* Update previous scale factor for next call */
  621.     *prev_scale = scale;
  623. }