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

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

语音压缩

开发平台：

Visual C++

melp_sub.c：源码内容
  1. /*
  3. 2.4 kbps MELP Proposed Federal Standard speech coder
  5. Fixed-point C code, version 1.0
  7. Copyright (c) 1998, 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).
  15. The fixed-point version of the voice codec Mixed Excitation Linear
  16. Prediction (MELP) is based on specifications on the C-language software
  17. simulation contained in GSM 06.06 which is protected by copyright and
  18. is the property of the European Telecommunications Standards Institute
  19. (ETSI). This standard is available from the ETSI publication office
  20. tel. +33 (0)4 92 94 42 58. ETSI has granted a license to United States
  21. Department of Defense to use the C-language software simulation contained
  22. in GSM 06.06 for the purposes of the development of a fixed-point
  23. version of the voice codec Mixed Excitation Linear Prediction (MELP).
  24. Requests for authorization to make other use of the GSM 06.06 or
  25. otherwise distribute or modify them need to be addressed to the ETSI
  26. Secretariat fax: +33 493 65 47 16.
  28. */
  29. /*
  31.   melp_sub.c: MELP-specific subroutines
  33. */
  35. #include <stdio.h>
  36. #include <math.h>
  37. #include "spbstd.h"
  38. #include "mathhalf.h"
  39. #include "wmops.h"
  40. #include "math_lib.h"
  41. #include "mat.h"
  42. #include "dsp_sub.h"
  43. #include "melp_sub.h"
  44. #include "pit.h"
  45. #include "constant.h"
  47. /*
  48.     Name: bpvc_ana.c
  49.     Description: Bandpass voicing analysis
  50.     Inputs:
  51.       speech[] - input speech signal
  52.       fpitch[] - initial (floating point) pitch estimates
  53.     Outputs: 
  54.       bpvc[] - bandpass voicing decisions
  55.       pitch[] - frame pitch estimates
  56.     Returns: void 
  58.     Copyright (c) 1995,1997 by Texas Instruments, Inc.  All rights reserved.
  59. */
  61. /* Q values
  62.    --------
  63.    speech - Q0
  64.    fpitch - Q7
  65.    bpvc - Q14
  66.    pitch - Q7
  68. */
  70. /* Filter orders */
  71. #define ENV_ORD 2
  72. #define BPF_ORD 6
  75. static Shortword PITCHMAX;
  76. static Shortword PITCHMIN;
  77. static Shortword PITCHMAX_Q7;
  78. static Shortword PITCHMIN_Q7;
  79. static Shortword FRAME;
  80. static Shortword NUM_BANDS;
  81. static Shortword PIT_BEG;
  82. static Shortword PIT_P_FR;
  83. static Shortword PIT_FR_BEG;
  84. static Shortword FIRST_CNTR;
  85. static Shortword BPF_BEG;
  86. static Shortword NUM_PITCHES;
  87. static Shortword LMIN;
  89. /* Static memory */
  90. static Shortword **bpfsp;
  91. static Shortword **bpfdelin;
  92. static Shortword **bpfdelout;
  93. static Shortword **envdel;
  94. static Shortword *envdel2;
  95. static Shortword *sigbuf;
  97. /* External variables */
  98. extern Shortword bpf_num[], bpf_den[];
  100. void bpvc_ana(Shortword speech[], Shortword fpitch[], Shortword bpvc[], 
  101.       Shortword pitch[])
  102. {
  104.     Shortword pcorr, temp, scale;
  105.     Shortword j,section;
  106.     Shortword filt_index;
  108.     /* Filter lowest band and estimate pitch */
  109.     v_equ(&sigbuf[PIT_BEG],&bpfsp[0][0],(Shortword)(PIT_P_FR-FRAME));
  110.     v_equ(&sigbuf[PIT_BEG+PIT_P_FR-FRAME],
  111.   &speech[PIT_FR_BEG+PIT_P_FR-FRAME],FRAME);
  113.     for (section=0; section<BPF_ORD/2; section++) {
  114.       iir_2nd_s(&sigbuf[PIT_BEG+PIT_P_FR-FRAME],
  115. &bpf_den[section*3],&bpf_num[section*3],
  116. &sigbuf[PIT_BEG+PIT_P_FR-FRAME],&bpfdelin[0][section*2],
  117. &bpfdelout[0][section*2],FRAME);
  118.     }
  119.     v_equ(&bpfsp[0][0],&sigbuf[PIT_BEG+FRAME],(Shortword)(PIT_P_FR-FRAME));
  121.     /* Scale signal for pitch correlations */
  122.     f_pitch_scale(&sigbuf[PIT_BEG],&sigbuf[PIT_BEG],PIT_P_FR);
  124.     *pitch = frac_pch(&sigbuf[FIRST_CNTR],&bpvc[0],fpitch[0],5,
  125.       PITCHMIN,PITCHMAX,PITCHMIN_Q7,PITCHMAX_Q7,LMIN);
  127.     for (j = 1; j < NUM_PITCHES; j++) {
  128.       temp = frac_pch(&sigbuf[FIRST_CNTR],&pcorr,fpitch[j],5,
  129.       PITCHMIN,PITCHMAX,PITCHMIN_Q7,PITCHMAX_Q7,LMIN);
  131.       /* choose largest correlation value */
  132.       if (pcorr > bpvc[0]) {
  133. *pitch = temp;
  134. bpvc[0] = pcorr; 
  135.       }
  136.     }
  137.     
  138.     /* Calculate bandpass voicing for frames */
  139.     
  140.     for (j = 1; j < NUM_BANDS; j++) {
  142.       /* Bandpass filter input speech */
  143.       v_equ(&sigbuf[PIT_BEG],&bpfsp[j][0],(Shortword)(PIT_P_FR-FRAME));
  144.       v_equ(&sigbuf[PIT_BEG+PIT_P_FR-FRAME],
  145.     &speech[PIT_FR_BEG+PIT_P_FR-FRAME],FRAME);
  147.       for (section=0; section<BPF_ORD/2; section++) {
  148.   filt_index = j*(BPF_ORD/2)*3 + section*3;
  149.   iir_2nd_s(&sigbuf[PIT_BEG+PIT_P_FR-FRAME],
  150.     &bpf_den[filt_index],&bpf_num[filt_index],
  151.     &sigbuf[PIT_BEG+PIT_P_FR-FRAME],&bpfdelin[j][section*2],
  152.     &bpfdelout[j][section*2],FRAME);
  153.       }
  154.       v_equ(&bpfsp[j][0],&sigbuf[PIT_BEG+FRAME],(Shortword)(PIT_P_FR-FRAME));
  156.       /* Scale signal for pitch correlations */
  157.       scale = f_pitch_scale(&sigbuf[PIT_BEG],&sigbuf[PIT_BEG],PIT_P_FR);
  159.       /* Check correlations for each frame */
  160.       temp = frac_pch(&sigbuf[FIRST_CNTR],&bpvc[j],*pitch,0,
  161.       PITCHMIN,PITCHMAX,PITCHMIN_Q7,PITCHMAX_Q7,LMIN);
  163.       /* Calculate envelope of bandpass filtered input speech */
  164.       /* update delay buffers without scaling */
  165.       temp = shr(envdel2[j],scale);
  166.       envdel2[j] = shr(sigbuf[PIT_BEG+FRAME-1],(Shortword)(-scale));
  167.       v_equ_shr(&sigbuf[PIT_BEG-ENV_ORD],&envdel[j][0],scale,ENV_ORD);
  168.       envelope(&sigbuf[PIT_BEG],temp,&sigbuf[PIT_BEG],PIT_P_FR);
  169.       v_equ_shr(&envdel[j][0],&sigbuf[PIT_BEG+FRAME-ENV_ORD],
  170. (Shortword)(-scale),ENV_ORD);
  172.       /* Scale signal for pitch correlations */
  173.       f_pitch_scale(&sigbuf[PIT_BEG],&sigbuf[PIT_BEG],PIT_P_FR);
  175.       /* Check correlations for each frame */
  176.       temp = frac_pch(&sigbuf[FIRST_CNTR],&pcorr,*pitch,0,
  177.       PITCHMIN,PITCHMAX,PITCHMIN_Q7,PITCHMAX_Q7,LMIN);
  179.       /* reduce envelope correlation */
  180.       pcorr = sub(pcorr,(Shortword)X01_Q14);
  182.       if (pcorr > bpvc[j])
  183. bpvc[j] = pcorr;
  184.     }
  186. } /* bpvc_ana */
  188. void bpvc_ana_init(Shortword fr, Shortword pmin, Shortword pmax, 
  189.    Shortword nbands, Shortword num_p, Shortword lmin)
  190. {
  192.     /* Initialize constants */
  193.     FRAME = fr;
  194.     PITCHMIN = pmin;
  195.     PITCHMAX = pmax;
  196.     PITCHMIN_Q7 = shl(pmin,7);
  197.     PITCHMAX_Q7 = shl(pmax,7);
  198.     NUM_BANDS = nbands;
  199.     NUM_PITCHES = num_p;
  200.     LMIN = lmin;
  201.     PIT_BEG = BPF_ORD;
  202.     PIT_P_FR = ((2*PITCHMAX)+1);
  203.     PIT_FR_BEG = (-PITCHMAX);
  204.     FIRST_CNTR = (PIT_BEG+PITCHMAX);
  205.     BPF_BEG = (PIT_BEG+PIT_P_FR-FRAME);
  207.     /* Allocate memory */
  208.     MEM_2ALLOC(malloc,bpfdelin,NUM_BANDS,BPF_ORD,Shortword);
  209.     v_zap(&bpfdelin[0][0],(Shortword)(NUM_BANDS*BPF_ORD));
  210.     MEM_2ALLOC(malloc,bpfdelout,NUM_BANDS,BPF_ORD,Shortword);
  211.     v_zap(&bpfdelout[0][0],(Shortword)(NUM_BANDS*BPF_ORD));
  212.     MEM_2ALLOC(malloc,bpfsp,NUM_BANDS,PIT_P_FR-FRAME,Shortword);
  213.     v_zap(&bpfsp[0][0],(Shortword)(NUM_BANDS*(PIT_P_FR-FRAME)));
  215.     MEM_2ALLOC(malloc,envdel,NUM_BANDS,ENV_ORD,Shortword);
  216.     v_zap(&envdel[0][0],(Shortword)(NUM_BANDS*ENV_ORD));
  217.     MEM_ALLOC(malloc,envdel2,NUM_BANDS,Shortword);
  218.     v_zap(envdel2,NUM_BANDS);
  220.     /* Allocate scratch buffer */
  221.     MEM_ALLOC(malloc,sigbuf,PIT_BEG+PIT_P_FR,Shortword);
  222. }
  225. /*
  226.     Name: dc_rmv.c
  227.     Description: remove DC from input signal
  228.     Inputs: 
  229.       sigin[] - input signal
  230.       dcdel[] - filter delay history (size DC_ORD)
  231.       frame - number of samples to filter
  232.     Outputs: 
  233.       sigout[] - output signal
  234.       dcdel[] - updated filter delay history
  235.     Returns: void 
  236.     See_Also:
  238.     Copyright (c) 1995,1997 by Texas Instruments, Inc.  All rights reserved.
  239. */
  241. /* Filter order */
  242. #define DC_ORD 4
  244. /* DC removal filter */
  245. /* 4th order Chebychev Type II 60 Hz removal filter */
  246. /* cutoff=60 Hz, stop=-30 dB */
  247. /* matlab commands: [z,p,k]=cheby2(4,30,0.015,'high');  */
  248. /*                      sos=zp2sos(z,p,k);        */
  249. /* order of sections swapped */
  250. /* Q13 */
  251. static Shortword dc_num[(DC_ORD/2)*3] = {
  252.            7769, -15534, 7769,
  253.            8007, -15999, 8007};
  255. /* sign of coefficients for dc_den is reversed */
  256. static Shortword dc_den[(DC_ORD/2)*3] = {
  257.            -8192, 15521, -7358,
  258.    -8192, 15986, -7836};
  260. void dc_rmv(Shortword sigin[],Shortword sigout[],Shortword delin[],
  261.     Shortword delout_hi[],Shortword delout_lo[],
  262.     Shortword frame)
  263. {
  264.   Shortword section;
  266.   /* Remove DC from input speech */
  267.   v_equ(sigout,sigin,frame);
  268.   for (section=0; section<DC_ORD/2; section++) {
  269.     iir_2nd_d(sigout,&dc_den[section*3],&dc_num[section*3],sigout,
  270.       &delin[section*2],&delout_hi[section*2],&delout_lo[section*2],
  271.       frame);
  272.   }
  273. }
  276. /*
  277.     Name: gain_ana.c
  278.     Description: analyze gain level for input signal
  279.     Inputs: 
  280.       sigin[] - input signal
  281.       pitch - pitch value (for pitch synchronous window)
  282.       minlength - minimum window length
  283.       maxlength - maximum window length
  284.     Outputs: 
  285.     Returns: log gain in dB
  286.     See_Also:
  288.     Copyright (c) 1997 by Texas Instruments, Inc.  All rights reserved.
  290.     Q values
  291.     --------
  292.     pitch - Q7
  293.     sigin (speech) - Q0
  295. */
  297. #define CONSTANT_SCALE 0
  298. #define MINGAIN        0
  299. #define LOG10OF2X2     1233         /* 2*log10(2) in Q11 */
  301. Shortword gain_ana(Shortword sigin[], Shortword pitch, 
  302.    Shortword minlength, Shortword maxlength)
  303. {
  304.     Shortword length;    /* Q0 */
  305.     Shortword flength;   /* Q6 */
  306.     Shortword gain;      /* Q8 */
  307.     Shortword pitch_Q6;  /* Q6 */
  308.     Shortword scale;
  309.     Shortword tmp_minlength;
  310.     Shortword sigbegin;
  311.     Shortword *temp_buf, *tmp_sig;
  312.     Shortword S_temp1, S_temp2;
  313.     Longword L_temp;
  314.     
  315.     /* initialize scaled pitch and minlength */
  316.     pitch_Q6 = shr(pitch,1);      /* Q7->Q6 */    data_move();
  318.     tmp_minlength = shl(minlength,6);    data_move();
  320.     /* Find shortest pitch multiple window length (floating point) */
  321.     flength = pitch_Q6;    data_move();
  322.     while (flength < tmp_minlength) {
  323.       /* increment complexity for while statement */
  324.       compare_nonzero();
  326.       flength = add(flength,pitch_Q6);      data_move();
  327.     }
  329.     /* Convert window length to integer and check against maximum */
  330.     length = shr(add(flength, (Shortword)X05_Q6), 6);     data_move();
  332.     /* increment complexity for if statement */
  333.     compare_nonzero();
  334.     if (length > maxlength) {
  335.       /* divide by 2 */
  336.       length = shr(length,1);    data_move();
  337.     }
  338.     
  339.     /* Calculate RMS gain in dB */
  340.     /*gain = 10.0*log10(0.01+(v_magsq(&sigin[-(length/2)],length)/length));*/
  341.     
  342.     /* use this adaptive scaling if more precision needed at low 
  343.        levels.  Seemed like it wasn't worth the mips */
  345.     sigbegin = negate(shr(length,1));
  347.     /* Right shift input signal and put in temp buffer */
  348.     MEM_ALLOC(MALLOC,temp_buf,length,Shortword);
  350. #if(CONSTANT_SCALE)
  351.     scale=3;
  352. #else
  353.     scale = 3;
  354.     v_equ_shr(temp_buf,&sigin[sigbegin],scale,length);
  355.     L_temp = L_v_magsq(temp_buf,length,0,1);
  357.     compare_zero();
  358.     if (L_temp) {
  359.       S_temp1 = norm_l(L_temp);
  360.       scale = sub(scale,shr(S_temp1,1));
  361.       if (scale < 0)
  362. scale = 0;
  363.     }
  364.     else
  365.       scale = 0;
  367. #endif
  369.     if (scale)
  370.       v_equ_shr(temp_buf,&sigin[sigbegin],scale,length);
  371.     else
  372.       v_equ(temp_buf,&sigin[sigbegin],length);
  373.     tmp_sig = temp_buf - sigbegin;
  376.     /* increment complexity for if statement */
  377.     compare_zero();
  378.     if (scale) {
  379.       L_temp = L_v_magsq(&tmp_sig[sigbegin],length,0,0);
  380.       S_temp1 = L_log10_fxp(L_temp,0);
  381.       S_temp2 = L_log10_fxp(L_deposit_l(length),0);
  382.       S_temp1 = sub(S_temp1,S_temp2);
  383.       /* shift right to counter-act for the shift in L_mult */
  384.       S_temp2 = extract_l(L_shr(L_mult(scale,LOG10OF2X2),1));
  385.       S_temp1 = add(S_temp1,S_temp2);
  386.       S_temp1 = mult(TEN_Q11,S_temp1);
  387.       gain = shl(S_temp1,1);    data_move();
  388.     }
  389.     else {
  390.       L_temp = L_v_magsq(&tmp_sig[sigbegin],length,0,0);
  391.       /* Add one to avoid log of a zero value */
  392.       if (L_temp == 0)
  393. S_temp1 = N2_Q11;
  394.       else
  395. S_temp1 = L_log10_fxp(L_temp,0);
  396.       S_temp2 = L_log10_fxp(L_deposit_l(length),0);
  397.       S_temp1 = sub(S_temp1,S_temp2);
  398.       S_temp1 = mult(TEN_Q11,S_temp1);
  399.       gain = shl(S_temp1,1);    data_move();
  400.     }
  402.     /* increment complexity for if statement */
  403.     compare_nonzero();
  404.     if (gain < MINGAIN) {
  405.       gain = MINGAIN;    data_move();
  406.     }
  408.     MEM_FREE(FREE,temp_buf);
  410.     return(gain);
  411. } /* gain_ana */
  413. /*
  414.     Name: lin_int_bnd.c
  415.     Description: Linear interpolation within bounds
  416.     Inputs:
  417.       x - input X value
  418.       xmin - minimum X value
  419.       xmax - maximum X value
  420.       ymin - minimum Y value
  421.       ymax - maximum Y value
  422.     Returns: y - interpolated and bounded y value
  424.     Copyright (c) 1995,1997 by Texas Instruments, Inc.  All rights reserved.
  426.     Q values:
  427.     x,xmin,xmax - Q8
  428.     y,ymin,ymax - Q15
  429. */
  431. Shortword lin_int_bnd(Shortword x,Shortword xmin,Shortword xmax,
  432.       Shortword ymin,Shortword ymax)
  434. {
  435.     Shortword y;
  436.     Shortword temp1,temp2;
  438.     if (x <= xmin)
  439.       y = ymin;
  441.     else if (x >= xmax)
  442.       y = ymax;
  444.     else {
  445.       /* y = ymin + (x-xmin)*(ymax-ymin)/(xmax-xmin); */
  446.       temp1 = sub(x,xmin);
  447.       temp2 = sub(ymax,ymin);
  448.       temp1 = mult(temp1,temp2);     /* temp1 in Q8 */
  449.       temp2 = sub(xmax,xmin);
  450.       /* temp1 always smaller than temp2 */
  451.       temp1 = divide_s(temp1,temp2);    /* temp1 in Q15 */
  452.       y = add(ymin,temp1);
  453.     }
  455.     return(y);
  456. }
  458. /*
  459.     Name: noise_est.c
  460.     Description: Estimate long-term noise floor
  461.     Inputs:
  462.       gain - input gain (in dB)
  463.       noise_gain - current noise gain estimate
  464.       up - maximum up stepsize
  465.       down - maximum down stepsize
  466.       min - minimum allowed gain
  467.       max - maximum allowed gain
  468.     Outputs:
  469.       noise_gain - updated noise gain estimate
  470.     Returns: void
  472.     Copyright (c) 1995,1997 by Texas Instruments, Inc.  All rights reserved.
  474.     Q values:
  475.     gain - Q8
  476.     *noise_gain - Q8
  477.     up - Q19
  478.     down - Q17
  479.     min - Q8
  480.     max - Q8
  481. */
  483. void noise_est(Shortword gain,Shortword *noise_gain,Shortword up,
  484.        Shortword down,Shortword min,Shortword max)
  486. {
  487.     Shortword temp1,temp2;
  488.     Longword L_noise_gain,L_temp;
  490.     /* Update noise_gain */
  491.     /* temp1 = add(*noise_gain,up);
  492.        temp2 = add(*noise_gain,down);  */
  493.     L_noise_gain = L_deposit_h(*noise_gain);    /* L_noise_gain in Q24 */
  494.     L_temp = L_shl(L_deposit_l(up),5);
  495.     L_temp = L_add(L_noise_gain,L_temp);
  496.     temp1 = round(L_temp);
  497.     L_temp = L_shl(L_deposit_l(down),7);
  498.     L_temp = L_add(L_noise_gain,L_temp);
  499.     temp2 = round(L_temp);
  501.     compare_nonzero();
  502.     if (gain > temp1)
  503.       *noise_gain = temp1;
  505.     else if (gain < temp2)
  506.       *noise_gain = temp2;
  508.     else
  509.       *noise_gain = gain;
  511.     /* Constrain total range of noise_gain */
  512.     compare_nonzero();
  513.     if (*noise_gain < min)
  514.       *noise_gain = min;
  515.     compare_nonzero();
  516.     if (*noise_gain > max)
  517.       *noise_gain = max;
  519. }
  521. /*
  522.     Name: noise_sup.c
  523.     Description: Perform noise suppression on speech gain
  524.     Inputs: (all in dB)
  525.       gain - input gain (in dB)
  526.       noise_gain - current noise gain estimate (in dB)
  527.       max_noise - maximum allowed noise gain 
  528.       max_atten - maximum allowed attenuation
  529.       nfact - noise floor boost
  530.     Outputs:
  531.       gain - updated gain 
  532.     Returns: void
  534.     Copyright (c) 1995,1997 by Texas Instruments, Inc.  All rights reserved.
  536.     Q values:
  537.     *gain - Q8
  538.     noise_gain - Q8
  539.     max_noise - Q8
  540.     max_atten - Q8
  541.     nfact - Q8
  542. */
  545. void noise_sup(Shortword *gain,Shortword noise_gain,Shortword max_noise,
  546.        Shortword max_atten,Shortword nfact)
  548. {
  549.     Shortword gain_lev,suppress;
  550.     Shortword temp;
  551.     Longword L_temp;
  553.     /* Reduce effect for louder background noise */
  554.     if (noise_gain > max_noise)
  555.       noise_gain = max_noise;
  557.     /* Calculate suppression factor */
  558.     gain_lev = sub(*gain,add(noise_gain,nfact));
  559.     compare_nonzero();
  560.     if (gain_lev > X0001_Q8) {
  561.         /* suppress = -10.0*log10(1.0 - pow(10.0,-0.1*gain_lev)); */
  562.         L_temp = L_mult((Shortword)M01_Q15,gain_lev);     /* L_temp in Q24 */
  563. temp = extract_h(L_shl(L_temp,4));     /* temp in Q12 */
  564. temp = pow10_fxp(temp,14);
  565. temp = sub(ONE_Q14,temp);
  566. suppress = mult(M10_Q11,log10_fxp(temp,14));   /* log returns Q12 */
  567. compare_nonzero();
  568. if (suppress > max_atten)
  569.   suppress = max_atten;
  570.     }
  571.     else
  572.       suppress = max_atten;
  574.     /* Apply suppression to input gain */
  575.     *gain = sub(*gain,suppress);
  577. } /* noise_sup */
  580. /*
  581.     Name: q_bpvc.c, q_bpvc_dec.c
  582.     Description: Quantize/decode bandpass voicing
  583.     Inputs:
  584.       bpvc, bpvc_index
  585.       bpthresh - threshold
  586.       NUM_BANDS - number of bands
  587.     Outputs: 
  588.       bpvc, bpvc_index
  589.     Returns: uv_flag - flag if unvoiced
  591.     Copyright (c) 1995,1997 by Texas Instruments, Inc.  All rights reserved.
  593.     Q values:
  594.     *bpvc - Q14
  595.     bpthresh - Q14
  596. */
  598. /* Compile constants */
  599. #define INVALID_BPVC 0001
  601. Shortword q_bpvc(Shortword *bpvc,Shortword *bpvc_index,Shortword bpthresh,
  602.  Shortword NUM_BANDS)
  604. {
  605.     Shortword j, uv_flag;
  607.     uv_flag = 1;     data_move();
  609.     if (bpvc[0] > bpthresh) {
  611. /* Voiced: pack bandpass voicing */
  612. uv_flag = 0;     data_move();
  613. *bpvc_index = 0;     data_move();
  614. bpvc[0] = ONE_Q14;     data_move();
  616. for (j = 1; j < NUM_BANDS; j++) {
  617.     *bpvc_index = shl(*bpvc_index,1);    /* left shift one bit */
  618.     if (bpvc[j] > bpthresh) {
  619. bpvc[j] = ONE_Q14;     data_move();
  620. *bpvc_index |= 1;     logic();
  621.     }
  622.     else {
  623. bpvc[j] = 0;     data_move();
  624. *bpvc_index |= 0;     logic();
  625.     }
  626. }
  628. /* Don't use invalid code (only top band voiced) */
  629. if (*bpvc_index == INVALID_BPVC) {
  630.     bpvc[(NUM_BANDS-1)] = 0;
  631.     *bpvc_index = 0;
  632. }
  633.     }
  634.     else {
  636. /* Unvoiced: force all bands unvoiced */
  637. *bpvc_index = 0;
  638. for (j = 0; j < NUM_BANDS; j++)
  639.     bpvc[j] = 0;
  640.     }
  641.     return(uv_flag);
  642. } /* q_bpvc */
  644. void q_bpvc_dec(Shortword *bpvc,Shortword *bpvc_index,Shortword uv_flag,
  645. Shortword NUM_BANDS)
  647. {
  648.     Shortword j;
  650.     if (uv_flag) {
  652. /* Unvoiced: set all bpvc to 0 */
  653. *bpvc_index = 0;
  654. bpvc[0] = 0;
  655.     }
  656.     
  657.     else {
  659. /* Voiced: set bpvc[0] to 1.0 */
  660. bpvc[0] = ONE_Q14;
  661.     }
  662.     
  663.     if (*bpvc_index == INVALID_BPVC) {
  665. /* Invalid code received: set higher band voicing to zero */
  666. *bpvc_index = 0;
  667.     }
  669.     /* Decode remaining bands */
  670.     for (j = NUM_BANDS-1; j > 0; j--) {
  671.         compare_nonzero();
  672. logic();
  673. if ((*bpvc_index & 1) == 1)
  674.     bpvc[j] = ONE_Q14;
  675. else
  676.     bpvc[j] = 0;
  677. *bpvc_index = shr(*bpvc_index,1);
  678.     }
  679. } /* q_bpvc_dec */
  682. /*
  683.     Name: q_gain.c, q_gain_dec.c
  684.     Description: Quantize/decode two gain terms using quasi-differential coding
  685.     Inputs:
  686.       gain[2],gain_index[2]
  687.       GN_QLO,GN_QUP,GN_QLEV for second gain term
  688.     Outputs: 
  689.       gain[2],gain_index[2]
  690.     Returns: void
  692.     Copyright (c) 1995,1997 by Texas Instruments, Inc.  All rights reserved.
  694.     Q values:
  695.     *gain - Q8
  696.     GN_QLO - Q8
  697.     GN_QUP - Q8
  698.     GN_QLEV_Q - Q10
  699. */
  701. /* Compile constants */
  702. #define GAIN_INT_DB_Q8 1280    /* (5*(1<<8)) */
  704. void q_gain(Shortword *gain,Shortword *gain_index,Shortword GN_QLO,
  705.     Shortword GN_QUP,Shortword GN_QLEV,Shortword GN_QLEV_Q,
  706.     Shortword double_flag,Shortword scale)
  708. {
  709.     static Shortword prev_gain = 0;
  710.     Shortword temp,temp2;
  712.     /* Quantize second gain term with uniform quantizer */
  713.     quant_u(&gain[1],&gain_index[1],GN_QLO,GN_QUP,GN_QLEV,GN_QLEV_Q,
  714.     double_flag,scale);
  715.     
  716.     /* Check for intermediate gain interpolation */
  717.     if (gain[0] < GN_QLO) {
  718.       gain[0] = GN_QLO;     data_move();
  719.     }
  720.     if (gain[0] > GN_QUP) {
  721.       gain[0] = GN_QUP;     data_move();
  722.     }
  724.     /* if (fabs(gain[1] - prev_gain) < GAIN_INT_DB && 
  725.          fabs(gain[0] - 0.5*(gain[1]+prev_gain)) < 3.0) */
  726.     temp = add(shr(gain[1],1),shr(prev_gain,1));
  727.     if (abs_s(sub(gain[1],prev_gain)) < GAIN_INT_DB_Q8 &&
  728. abs_s(sub(gain[0],temp)) < THREE_Q8) {
  730. /* interpolate and set special code */
  731.         /* gain[0] = 0.5*(gain[1]+prev_gain); */
  732.         gain[0] = temp;
  733. gain_index[0] = 0;
  734.     }
  735.     else {
  737. /* Code intermediate gain with 7-levels */
  738. if (prev_gain < gain[1]) {
  739.     temp = prev_gain;     data_move();
  740.     temp2 = gain[1];     data_move();
  741. }
  742. else {
  743.     temp = gain[1];     data_move();
  744.     temp2 = prev_gain;     data_move();
  745. }
  746. temp = sub(temp,SIX_Q8);
  747. temp2 = add(temp2,SIX_Q8);
  748. if (temp < GN_QLO) {
  749.   temp = GN_QLO;     data_move();
  750. }
  751. if (temp2 > GN_QUP) {
  752.   temp2 = GN_QUP;     data_move();
  753. }
  754. quant_u(&gain[0],&gain_index[0],temp,temp2,6,SIX_Q12,0,3);
  756. /* Skip all-zero code */
  757. gain_index[0] = add(gain_index[0],1);
  758.     }
  760.     /* Update previous gain for next time */
  761.     prev_gain = gain[1];     data_move();
  762.     
  763. } /* q_gain */
  765. void q_gain_dec(Shortword *gain,Shortword *gain_index,Shortword GN_QLO,
  766. Shortword GN_QUP,Shortword GN_QLEV_Q,Shortword scale)
  767. {
  769.     static Shortword prev_gain = 0;
  770.     static Shortword prev_gain_err = 0;
  771.     Shortword temp,temp2;
  773.     /* Decode second gain term */
  774.     quant_u_dec(gain_index[1],&gain[1],GN_QLO,GN_QUP,GN_QLEV_Q,scale);
  775.     
  776.     if (gain_index[0] == 0) {
  778. /* interpolation bit code for intermediate gain */
  779.         temp = sub(gain[1],prev_gain);
  780. temp = abs_s(temp);
  781. compare_nonzero();
  782. if (temp > GAIN_INT_DB_Q8) {
  783.     /* Invalid received data (bit error) */
  784.     if (prev_gain_err == 0) {
  785. /* First time: don't allow gain excursion */
  786. gain[1] = prev_gain;
  787.     }
  788.     prev_gain_err = 1;
  789. }
  790. else 
  791.   prev_gain_err = 0;
  793. /* Use interpolated gain value */
  794. /* gain[0] = 0.5*(gain[1]+prev_gain); */
  795. gain[0] = add(shr(gain[1],1),shr(prev_gain,1));
  796.     }
  798.     else {
  800. /* Decode 7-bit quantizer for first gain term */
  801. prev_gain_err = 0;
  802. gain_index[0] = sub(gain_index[0],1);
  803. compare_nonzero();
  804. if (prev_gain < gain[1]) {
  805.     temp = prev_gain;
  806.     temp2 = gain[1];
  807. }
  808. else {
  809.     temp = gain[1];
  810.     temp2 = prev_gain;
  811. }
  812. temp = sub(temp,SIX_Q8);
  813. temp2 = add(temp2,SIX_Q8);
  814. compare_nonzero();
  815. if (temp < GN_QLO)
  816.   temp = GN_QLO;
  817. compare_nonzero();
  818. if (temp2 > GN_QUP)
  819.   temp2 = GN_QUP;
  820. quant_u_dec(gain_index[0],&gain[0],temp,temp2,SIX_Q12,3);
  821.     }
  823.     /* Update previous gain for next time */
  824.     prev_gain = gain[1];    data_move();
  825.     
  826. } /* q_gain_dec */
  828. /*
  829.     Name: scale_adj.c
  830.     Description: Adjust scaling of output speech signal.
  831.     Inputs:
  832.       speech - speech signal
  833.       gain - desired RMS gain (log gain)
  834.       prev_scale - previous scale factor
  835.       length - number of samples in signal
  836.       SCALEOVER - number of points to interpolate scale factor
  837.     Warning: SCALEOVER is assumed to be less than length.
  838.     Outputs: 
  839.       speech - scaled speech signal
  840.       prev_scale - updated previous scale factor
  841.     Returns: void
  843.     Copyright (c) 1995,1997 by Texas Instruments, Inc.  All rights reserved.
  845.     Q values:
  846.     *speech - Q0
  847.     gain - Q12
  848.     *prev_scale - Q13
  849. */
  851. void scale_adj(Shortword *speech, Shortword gain, Shortword *prev_scale, 
  852.        Shortword length, Shortword SCALEOVER, 
  853.        Shortword INV_SCALEOVER_Q18)
  855. {
  856.     Shortword i;
  857.     Shortword scale;
  858.     Shortword shift,log_magsq,log_length;
  859.     Shortword temp;
  860.     Shortword *tempbuf;
  861.     Longword L_magsq,L_length,interp1,interp2;
  862.     Longword L_temp;
  864.     /* Calculate desired scaling factor to match gain level */
  865.     /* scale = gain / (sqrt(v_magsq(&speech[0],length) / length) + .01); */
  866.     /* find normalization factor for buffer */
  867.     MEM_ALLOC(MALLOC,tempbuf,length,Shortword);
  869.     shift = 4;
  870.     v_equ_shr(tempbuf,speech,shift,length);
  871.     L_magsq = L_v_magsq(tempbuf,length,0,1);
  873.     compare_zero();
  874.     if (L_magsq) {
  875.       /* normalize with 1 bit of headroom */
  876.       temp = norm_l(L_magsq);
  877.       temp = sub(temp,1);
  878.       shift = sub(shift,shr(temp,1));
  879.     }
  880.     else
  881.       shift = 0;
  883.     v_equ_shr(tempbuf,speech,shift,length);
  885.     /* exp = log(2^shift) */
  886.     shift = shl(shift,1);     /* total compensation = shift*2 */
  887.     temp = shl(ONE_Q8,shift);
  888.     shift = log10_fxp(temp,8);    /* shift in Q12 */
  890.     L_magsq = L_v_magsq(tempbuf,length,0,0);
  891.     L_magsq = L_add(L_magsq,1);     /* ensure L_magsq is not zero */
  892.     log_magsq = L_log10_fxp(L_magsq,0);      /* log_magsq in Q11 */
  893.     /* L_magsq = log_magsq in Q12 */
  894.     L_magsq = L_deposit_l(log_magsq);
  895.     L_magsq = L_shl(L_magsq,1);
  896.     /* compensate for normalization */
  897.     /* L_magsq = log magnitude/2 in Q13 */
  898.     L_temp = L_deposit_l(shift);
  899.     L_magsq = L_add(L_magsq,L_temp);
  901.     temp = shl(length,7);
  902.     log_length = log10_fxp(temp,7);      /* log_length in Q12 */
  903.     /* L_length = log_length/2 in Q13 */
  904.     L_length = L_deposit_l(log_length);
  906.     L_temp = L_deposit_l(gain);
  907.     L_temp = L_shl(L_temp,1);      /* L_temp in Q13 */
  908.     L_temp = L_sub(L_temp,L_magsq);
  909.     L_temp = L_add(L_temp,L_length);
  910.     L_temp = L_shr(L_temp,1);      /* Q13 -> Q12 */
  911.     temp = extract_l(L_temp);     /* temp in Q12 */
  912.     scale = pow10_fxp(temp,13);
  914.     /* interpolate scale factors for first SCALEOVER points */
  915.     for (i = 1; i < SCALEOVER; i++) {
  916.       /* speech[i-1] *= ((scale*i + *prev_scale*(SCALEOVER-i))
  917.       * (1.0/SCALEOVER) ); */
  919.       temp = sub(SCALEOVER,i);
  920.       temp = shl(temp,11);
  921.       L_temp = L_mult(temp,INV_SCALEOVER_Q18);  /* L_temp in Q30 */
  922.       L_temp = L_shl(L_temp,1);                 /* L_temp in Q31 */
  923.       temp = extract_h(L_temp);                 /* temp in Q15 */
  924.       interp1 = L_mult(*prev_scale,temp);       /* interp1 in Q29 */
  926.       temp = shl(i,11);
  927.       L_temp = L_mult(temp,INV_SCALEOVER_Q18);  /* L_temp in Q30 */
  928.       L_temp = L_shl(L_temp,1);                 /* L_temp in Q31 */
  929.       temp = extract_h(L_temp);                 /* temp in Q15 */
  930.       interp2 = L_mult(scale,temp);             /* interp2 in Q29 */
  931.       L_temp = L_add(interp1,interp2);
  932.       interp1 = extract_h(L_temp);              /* interp1 in Q13 */
  934.       L_temp = L_mult(speech[i-1],(Shortword)interp1);
  935.       L_temp = L_shl(L_temp,2);
  936.       speech[i-1] = extract_h(L_temp);
  937.     }
  938.     
  939.     /* Scale rest of signal */
  940.     v_scale_shl(&speech[SCALEOVER-1],scale,(Shortword)(length-SCALEOVER+1),2);
  942.     /* Update previous scale factor for next call */
  943.     *prev_scale = scale;      data_move();
  945.     MEM_FREE(FREE,tempbuf);
  947. } /* scale_adj */