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

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

语音压缩

开发平台：

Visual C++

melp_syn.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. /*
  19.     Name: melp_syn.c
  20.     Description: MELP synthesis
  21.       This program takes the new parameters for a speech
  22.       frame and synthesizes the output speech.  It keeps
  23.       an internal record of the previous frame parameters
  24.       to use for interpolation.
  25.     Inputs:
  26.       *par - MELP parameter structure
  27.     Outputs: 
  28.       speech[] - output speech signal
  29.     Returns: void
  30. */
  32. /* compiler include files */
  33.  
  34. #include <stdio.h>
  35. #include <math.h>
  36. #include "melp.h"
  37. #include "spbstd.h"
  38. #include "lpc.h"
  39. #include "mat.h"
  40. #include "vq.h"
  41. #include "fs.h"
  43. /* compiler constants */
  44.  
  45. #if (MIX_ORD > DISP_ORD)
  46. #define BEGIN MIX_ORD
  47. #else
  48. #define BEGIN DISP_ORD
  49. #endif
  51. #define TILT_ORD 1
  52. #define SYN_GAIN 1000.0
  53. #define SCALEOVER 10
  54. #define PDEL SCALEOVER
  56. /* external memory references */
  57.  
  58. extern float bp_cof[NUM_BANDS][MIX_ORD+1];
  59. extern float disp_cof[DISP_ORD+1];
  60. extern float msvq_cb[];
  61. extern float fsvq_cb[];
  62. extern int fsvq_weighted;
  64. /* temporary memory */
  66. static float sigbuf[BEGIN+PITCHMAX];
  67. static float sig2[BEGIN+PITCHMAX];
  68. static float fs_real[PITCHMAX];
  70. /* permanent memory */
  71.  
  72. static int firstcall = 1; /* Just used for noise gain init */
  73. static int prev_gain_err;
  74. static float sigsave[PITCHMAX];
  75. static struct melp_param prev_par;
  76. static int syn_begin;
  77. static float prev_scale;
  78. static float noise_gain = MIN_NOISE;
  79. static float pulse_del[MIX_ORD],noise_del[MIX_ORD];
  80. static float lpc_del[LPC_ORD],ase_del[LPC_ORD],tilt_del[TILT_ORD];
  81. static float disp_del[DISP_ORD];
  83. static struct msvq_param vq_par;  /* MSVQ parameters */
  85. static struct msvq_param fs_vq_par;  /* Fourier series VQ parameters */
  86. static float w_fs_inv[NUM_HARM];
  88. /* these can be saved or recomputed */
  89. static float prev_pcof[MIX_ORD+1],prev_ncof[MIX_ORD+1];
  90. static float prev_tilt;
  91. static float prev_gain;
  93. void melp_syn(struct melp_param *par,float sp_out[])
  95. {
  97.     int i, gaincnt;
  98.     int erase;
  99.     int length;
  100.     float intfact, ifact, ifact_gain;
  101.     float gain,pulse_gain,pitch,jitter;
  102.     float curr_tilt,tilt_cof[TILT_ORD+1];
  103.     float temp,sig_prob;
  104.     float lsf[LPC_ORD+1];
  105.     float lpc[LPC_ORD+1];
  106.     float ase_num[LPC_ORD+1],ase_den[LPC_ORD+1];
  107.     float curr_pcof[MIX_ORD+1],curr_ncof[MIX_ORD+1];
  108.     float pulse_cof[MIX_ORD+1],noise_cof[MIX_ORD+1];
  109.     
  110.     /* Copy previous period of processed speech to output array */
  111.     if (syn_begin > 0) {
  112. if (syn_begin > FRAME) {
  113.     v_equ(&sp_out[0],&sigsave[0],FRAME);
  114.     /* past end: save remainder in sigsave[0] */
  115.     v_equ(&sigsave[0],&sigsave[FRAME],syn_begin-FRAME);
  116. }
  117. else 
  118.   v_equ(&sp_out[0],&sigsave[0],syn_begin);
  119.     }
  120.     
  121.     erase = 0; /* no erasures yet */
  122.     
  123.     /* Update MSVQ information */
  124.     par->msvq_stages = vq_par.num_stages;
  125.     par->msvq_bits = vq_par.num_bits;
  126.     par->msvq_levels = vq_par.num_levels;
  127.     par->msvq_index = vq_par.indices;
  128.     par->fsvq_index = fs_vq_par.indices;
  129.     
  130.     /* Read and decode channel input buffer */
  131.     erase = melp_chn_read(par,&prev_par);
  133.     if (par->uv_flag != 1 && !erase) { 
  134. /* Un-weight Fourier magnitudes */
  135. window(&par->fs_mag[0],w_fs_inv,&par->fs_mag[0],NUM_HARM);
  136.     }
  138.     /* Update adaptive noise level estimate based on last gain */
  139.     if (firstcall) {
  140. firstcall = 0;
  141. noise_gain = par->gain[NUM_GAINFR-1];
  142.     }
  143.     
  144.     else if (!erase) {
  145. for (i = 0; i < NUM_GAINFR; i++) {
  146.     noise_est(par->gain[i],&noise_gain,UPCONST,DOWNCONST,
  147.       MIN_NOISE,MAX_NOISE);
  149.     /* Adjust gain based on noise level (noise suppression) */
  150.     noise_sup(&par->gain[i],noise_gain,MAX_NS_SUP,MAX_NS_ATT,NFACT);
  152. }
  153.     
  154.     }
  155.     
  156.     /* Clamp LSP bandwidths to avoid sharp LPC filters */
  157.     lpc_clamp(par->lsf,BWMIN,LPC_ORD);
  158.     
  159.     /* Calculate spectral tilt for current frame for spectral enhancement */
  160.     tilt_cof[0] = 1.0;
  161.     lpc_lsp2pred(par->lsf,lpc,LPC_ORD);
  162.     lpc_pred2refl(lpc,sig2,LPC_ORD);
  163.     if (sig2[1] < 0.0)
  164.       curr_tilt = 0.5*sig2[1];
  165.     else
  166.       curr_tilt = 0.0;
  167.     
  168.     /* Disable pitch interpolation for high-pitched onsets */
  169.     if (par->pitch < 0.5*prev_par.pitch && 
  170. par->gain[0] > 6.0 + prev_par.gain[NUM_GAINFR-1]) {
  172. /* copy current pitch into previous */
  173. prev_par.pitch = par->pitch;
  174.     }
  175.     
  176.     /* Set pulse and noise coefficients based on voicing strengths */
  177.     v_zap(curr_pcof,MIX_ORD+1);
  178.     v_zap(curr_ncof,MIX_ORD+1);
  179.     for (i = 0; i < NUM_BANDS; i++) {
  180. if (par->bpvc[i] > 0.5)
  181.     v_add(curr_pcof,&bp_cof[i][0],MIX_ORD+1);
  182. else
  183.     v_add(curr_ncof,&bp_cof[i][0],MIX_ORD+1);
  184.     }
  186.     /* Process each pitch period */
  187.     
  188.     while (syn_begin < FRAME) {
  190. /* interpolate previous and current parameters */
  192. ifact = ((float) syn_begin ) / FRAME;
  194. if (syn_begin >= GAINFR) {
  195.     gaincnt = 2;
  196.     ifact_gain = ((float) syn_begin-GAINFR) / GAINFR;
  197. }
  198. else {
  199.     gaincnt = 1;
  200.     ifact_gain = ((float) syn_begin) / GAINFR;
  201. }
  203. /* interpolate gain */
  204. if (gaincnt > 1) {
  205.     gain = ifact_gain*par->gain[gaincnt-1] + 
  206. (1.0-ifact_gain)*par->gain[gaincnt-2];
  207. }
  208. else {
  209.     gain = ifact_gain*par->gain[gaincnt-1] + 
  210. (1.0-ifact_gain)*prev_par.gain[NUM_GAINFR-1];
  211. }
  213. /* Set overall interpolation path based on gain change */
  215. temp = par->gain[NUM_GAINFR-1] - prev_par.gain[NUM_GAINFR-1];
  216. if (fabs(temp) > 6) {
  218.     /* Power surge: use gain adjusted interpolation */
  219.     intfact = (gain - prev_par.gain[NUM_GAINFR-1]) / temp;
  220.     if (intfact > 1.0)
  221. intfact = 1.0;
  222.     if (intfact < 0.0)
  223. intfact = 0.0;
  224. }
  225. else
  227.     /* Otherwise, linear interpolation */
  228.     intfact = ((float) syn_begin) / FRAME;
  230. /* interpolate LSF's and convert to LPC filter */
  231. interp_array(prev_par.lsf,par->lsf,lsf,intfact,LPC_ORD+1);
  232. lpc_lsp2pred(lsf,lpc,LPC_ORD);
  234. /* Check signal probability for adaptive spectral enhancement filter */
  235. sig_prob = lin_int_bnd(gain,noise_gain+12.0,noise_gain+30.0,
  236.        0.0,1.0);
  238. /* Calculate adaptive spectral enhancement filter coefficients */
  239. ase_num[0] = 1.0;
  240. lpc_bw_expand(lpc,ase_num,sig_prob*ASE_NUM_BW,LPC_ORD);
  241. lpc_bw_expand(lpc,ase_den,sig_prob*ASE_DEN_BW,LPC_ORD);
  242. tilt_cof[1] = sig_prob*(intfact*curr_tilt + 
  243. (1.0-intfact)*prev_tilt);
  245. /* interpolate pitch and pulse gain */
  246. pitch = intfact*par->pitch + (1.0-intfact)*prev_par.pitch;
  247. pulse_gain = SYN_GAIN*sqrt(pitch);
  249. /* interpolate pulse and noise coefficients */
  250. temp = sqrt(ifact);
  251. interp_array(prev_pcof,curr_pcof,pulse_cof,temp,MIX_ORD+1);
  252. interp_array(prev_ncof,curr_ncof,noise_cof,temp,MIX_ORD+1);
  254. /* interpolate jitter */
  255. jitter = ifact*par->jitter + 
  256.     (1.0-ifact)*prev_par.jitter;
  258. /* convert gain to linear */
  259. gain = pow(10.0,0.05*gain);
  261. /* Set period length based on pitch and jitter */
  262. rand_num(&temp,1.0,1);
  263. length = pitch * (1.0-jitter*temp) + 0.5;
  264. if (length < PITCHMIN)
  265.     length = PITCHMIN;
  266. if (length > PITCHMAX)
  267.     length = PITCHMAX;
  269. /* Use inverse DFT for pulse excitation */
  270. fill(fs_real,1.0,length);
  271. fs_real[0] = 0.0;
  272. interp_array(prev_par.fs_mag,par->fs_mag,&fs_real[1],intfact,
  273.      NUM_HARM);
  274. idft_real(fs_real,&sigbuf[BEGIN],length);
  276. /* Delay overall signal by PDEL samples (circular shift) */
  277. /* use fs_real as a scratch buffer */
  278. v_equ(fs_real,&sigbuf[BEGIN],length);
  279. v_equ(&sigbuf[BEGIN+PDEL],fs_real,length-PDEL);
  280. v_equ(&sigbuf[BEGIN],&fs_real[length-PDEL],PDEL);
  282. /* Scale by pulse gain */
  283. v_scale(&sigbuf[BEGIN],pulse_gain,length);
  285. /* Filter and scale pulse excitation */
  286. v_equ(&sigbuf[BEGIN-MIX_ORD],pulse_del,MIX_ORD);
  287. v_equ(pulse_del,&sigbuf[length+BEGIN-MIX_ORD],MIX_ORD);
  288. zerflt(&sigbuf[BEGIN],pulse_cof,&sigbuf[BEGIN],MIX_ORD,length);
  290. /* Get scaled noise excitation */
  291. rand_num(&sig2[BEGIN],(1.732*SYN_GAIN),length);
  293. /* Filter noise excitation */
  294. v_equ(&sig2[BEGIN-MIX_ORD],noise_del,MIX_ORD);
  295. v_equ(noise_del,&sig2[length+BEGIN-MIX_ORD],MIX_ORD);
  296. zerflt(&sig2[BEGIN],noise_cof,&sig2[BEGIN],MIX_ORD,length);
  298. /* Add two excitation signals (mixed excitation) */
  299. v_add(&sigbuf[BEGIN],&sig2[BEGIN],length);
  301. /* Adaptive spectral enhancement */
  302. v_equ(&sigbuf[BEGIN-LPC_ORD],ase_del,LPC_ORD);
  303. lpc_synthesis(&sigbuf[BEGIN],&sigbuf[BEGIN],ase_den,LPC_ORD,length);
  304. v_equ(ase_del,&sigbuf[BEGIN+length-LPC_ORD],LPC_ORD);
  305. zerflt(&sigbuf[BEGIN],ase_num,&sigbuf[BEGIN],LPC_ORD,length);
  306. v_equ(&sigbuf[BEGIN-TILT_ORD],tilt_del,TILT_ORD);
  307. v_equ(tilt_del,&sigbuf[length+BEGIN-TILT_ORD],TILT_ORD);
  308. zerflt(&sigbuf[BEGIN],tilt_cof,&sigbuf[BEGIN],TILT_ORD,length);
  310. /* Perform LPC synthesis filtering */
  311. v_equ(&sigbuf[BEGIN-LPC_ORD],lpc_del,LPC_ORD);
  312. lpc_synthesis(&sigbuf[BEGIN],&sigbuf[BEGIN],lpc,LPC_ORD,length);
  313. v_equ(lpc_del,&sigbuf[length+BEGIN-LPC_ORD],LPC_ORD);
  315. /* Adjust scaling of synthetic speech */
  316. scale_adj(&sigbuf[BEGIN],gain,&prev_scale,length,SCALEOVER);
  318. /* Implement pulse dispersion filter */
  319. v_equ(&sigbuf[BEGIN-DISP_ORD],disp_del,DISP_ORD);
  320. v_equ(disp_del,&sigbuf[length+BEGIN-DISP_ORD],DISP_ORD);
  321. zerflt(&sigbuf[BEGIN],disp_cof,&sigbuf[BEGIN],DISP_ORD,length);
  323. /* Copy processed speech to output array (not past frame end) */
  324. if (syn_begin+length > FRAME) {
  325.     v_equ(&sp_out[syn_begin],&sigbuf[BEGIN],FRAME-syn_begin);
  327.     /* past end: save remainder in sigsave[0] */
  328.     v_equ(&sigsave[0],&sigbuf[BEGIN+FRAME-syn_begin],
  329.   length-(FRAME-syn_begin));
  330. }
  332. else
  333.     v_equ(&sp_out[syn_begin],&sigbuf[BEGIN],length);
  335. /* Update syn_begin for next period */
  336. syn_begin += length;
  338.     }
  340.     /* Save previous pulse and noise filters for next frame */
  341.     v_equ(prev_pcof,curr_pcof,MIX_ORD+1);
  342.     v_equ(prev_ncof,curr_ncof,MIX_ORD+1);
  343.     
  344.     /* Copy current parameters to previous parameters for next time */
  345.     prev_par = *par;
  346.     prev_tilt = curr_tilt;
  347.     
  348.     /* Update syn_begin for next frame */
  349.     syn_begin -= FRAME;
  350.     
  351. }
  354. /* 
  355.  *
  356.  * Subroutine melp_syn_init(): perform initialization for melp 
  357.  * synthesis
  358.  *
  359.  */
  361. void melp_syn_init()
  362. {
  363.     int i;
  364.     float w_fs[NUM_HARM];
  366.     v_zap(prev_par.gain,NUM_GAINFR);
  367.     prev_par.pitch = UV_PITCH;
  368.     prev_par.lsf[0] = 0.0;
  369.     for (i = 1; i < LPC_ORD+1; i++)
  370.       prev_par.lsf[i] = prev_par.lsf[i-1] + (1.0/(LPC_ORD+1));
  371.     prev_par.jitter = 0.0;
  372.     v_zap(&prev_par.bpvc[0],NUM_BANDS);
  373.     prev_tilt=0.0;
  374.     prev_gain = 0.0;
  375.     prev_scale = 0.0;
  376.     syn_begin = 0;
  377.     noise_gain = MIN_NOISE;
  378.     firstcall = 1;
  379.     prev_gain_err = 0;
  380.     v_zap(pulse_del,MIX_ORD);
  381.     v_zap(noise_del,MIX_ORD);
  382.     v_zap(lpc_del,LPC_ORD);
  383.     v_zap(ase_del,LPC_ORD);
  384.     v_zap(tilt_del,TILT_ORD);
  385.     v_zap(disp_del,DISP_ORD);
  386.     v_zap(sig2,BEGIN+PITCHMAX);
  387.     v_zap(sigbuf,BEGIN+PITCHMAX);
  388.     v_zap(sigsave,PITCHMAX);
  389.     v_zap(prev_pcof,MIX_ORD+1);
  390.     v_zap(prev_ncof,MIX_ORD+1);
  391.     prev_ncof[MIX_ORD/2] = 1.0;
  393.     fill(prev_par.fs_mag,1.0,NUM_HARM);
  395.     /* 
  396.      * Initialize multi-stage vector quantization (read codebook) 
  397.      */
  398.  
  399.     vq_par.num_best = MSVQ_M;
  400.     vq_par.num_stages = 4;
  401.     vq_par.dimension = 10;
  403.     /* 
  404.      * Allocate memory for number of levels per stage and indices
  405.      * and for number of bits per stage 
  406.      */
  407.  
  408.     MEM_ALLOC(MALLOC,vq_par.num_levels,vq_par.num_stages,int);
  409.     MEM_ALLOC(MALLOC,vq_par.indices,vq_par.num_stages,int);
  410.     MEM_ALLOC(MALLOC,vq_par.num_bits,vq_par.num_stages,int);
  413.     vq_par.num_levels[0] = 128;
  414.     vq_par.num_levels[1] = 64;
  415.     vq_par.num_levels[2] = 64;
  416.     vq_par.num_levels[3] = 64;
  418.     vq_par.num_bits[0] = 7;
  419.     vq_par.num_bits[1] = 6;
  420.     vq_par.num_bits[2] = 6;
  421.     vq_par.num_bits[3] = 6;
  423.     vq_par.cb = msvq_cb;
  425.     /* Scale codebook to 0 to 1 */
  426.     if (fsvq_weighted == 0)
  427.       v_scale(vq_par.cb,(2.0/FSAMP),3200);
  429.     /* 
  430.      * Initialize Fourier magnitude vector quantization (read codebook) 
  431.      */
  432.  
  433.     fs_vq_par.num_best = 1;
  434.     fs_vq_par.num_stages = 1;
  435.     fs_vq_par.dimension = NUM_HARM;
  437.     /* 
  438.      * Allocate memory for number of levels per stage and indices
  439.      * and for number of bits per stage 
  440.      */
  441.  
  442.     MEM_ALLOC(MALLOC,fs_vq_par.num_levels,fs_vq_par.num_stages,int);
  443.     MEM_ALLOC(MALLOC,fs_vq_par.indices,fs_vq_par.num_stages,int);
  444.     MEM_ALLOC(MALLOC,fs_vq_par.num_bits,fs_vq_par.num_stages,int);
  447.     fs_vq_par.num_levels[0] = FS_LEVELS;
  449.     fs_vq_par.num_bits[0] = FS_BITS;
  451.     fs_vq_par.cb = fsvq_cb;
  453.     /* 
  454.      * Initialize fixed MSE weighting and inverse of weighting 
  455.      */
  457.     vq_fsw(w_fs, NUM_HARM, 60.0);
  458.     for (i = 0; i < NUM_HARM; i++)
  459.       w_fs_inv[i] = 1.0/w_fs[i];
  461.     /* 
  462.      * Pre-weight codebook (assume single stage only) 
  463.      */
  465.     if (fsvq_weighted == 0)
  466.       {
  467.   fsvq_weighted = 1;
  468.   for (i = 0; i < fs_vq_par.num_levels[0]; i++)
  469.     window(&fs_vq_par.cb[i*NUM_HARM],w_fs,&fs_vq_par.cb[i*NUM_HARM],
  470.    NUM_HARM);
  471.       }
  473. }