/*---------------------------------------------------------------------------*\ FILE........: quantise.c AUTHOR......: David Rowe DATE CREATED: 31/5/92 Quantisation functions for the sinusoidal coder. \*---------------------------------------------------------------------------*/ /* All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License version 2.1, as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #include #include #include #include "defines.h" #include "dump.h" #include "quantise.h" #include "lpc.h" #include "lsp.h" #include "four1.h" #include "codebook.h" #define LSP_DELTA1 0.01 /* grid spacing for LSP root searches */ #define MAX_CB 20 /* max number of codebooks */ /* describes each codebook */ typedef struct { int k; /* dimension of vector */ int log2m; /* number of bits in m */ int m; /* elements in codebook */ float *fn; /* file name of text file storing the VQ */ } LSP_CB; /* lsp_q describes entire quantiser made up of several codebooks */ #ifdef OLDER /* 10+10+6+6 = 32 bit LSP difference split VQ */ LSP_CB lsp_q[] = { {3, 1024, "/usr/src/freeswitch/libs/libcodec2-1.0/unittest/lspd123.txt"}, {3, 1024, "/usr/src/freeswitch/libs/libcodec2-1.0/unittest/lspd456.txt"}, {2, 64, "/usr/src/freeswitch/libs/libcodec2-1.0/unittest/lspd78.txt"}, {2, 64, "/usr/src/freeswitch/libs/libcodec2-1.0/unittest/lspd910.txt"}, {0, 0, ""} }; #endif LSP_CB lsp_q[] = { {1,4,16, codebook_lsp1 }, {1,4,16, codebook_lsp2 }, {1,4,16, codebook_lsp3 }, {1,4,16, codebook_lsp4 }, {1,4,16, codebook_lsp5 }, {1,4,16, codebook_lsp6 }, {1,4,16, codebook_lsp7 }, {1,3,8, codebook_lsp8 }, {1,3,8, codebook_lsp9 }, {1,2,4, codebook_lsp10 }, {0,0,0, NULL }, }; /* ptr to each codebook */ static float *plsp_cb[MAX_CB]; /*---------------------------------------------------------------------------*\ FUNCTION HEADERS \*---------------------------------------------------------------------------*/ float speech_to_uq_lsps(float lsp[], float ak[], float Sn[], float w[], int order); /*---------------------------------------------------------------------------*\ FUNCTIONS \*---------------------------------------------------------------------------*/ int lsp_bits(int i) { return lsp_q[i].log2m; } /*---------------------------------------------------------------------------*\ quantise_uniform Simulates uniform quantising of a float. \*---------------------------------------------------------------------------*/ void quantise_uniform(float *val, float min, float max, int bits) { int levels = 1 << (bits-1); float norm; int index; /* hard limit to quantiser range */ printf("min: %f max: %f val: %f ", min, max, val[0]); if (val[0] < min) val[0] = min; if (val[0] > max) val[0] = max; norm = (*val - min)/(max-min); printf("%f norm: %f ", val[0], norm); index = fabs(levels*norm + 0.5); *val = min + index*(max-min)/levels; printf("index %d val_: %f\n", index, val[0]); } /*---------------------------------------------------------------------------*\ lspd_quantise Simulates differential lsp quantiser \*---------------------------------------------------------------------------*/ void lsp_quantise( float lsp[], float lsp_[], int order ) { int i; float dlsp[LPC_MAX]; float dlsp_[LPC_MAX]; dlsp[0] = lsp[0]; for(i=1; i {Am} LPC decode */ return snr; } /*---------------------------------------------------------------------------*\ aks_to_M2() Transforms the linear prediction coefficients to spectral amplitude samples. This function determines A(m) from the average energy per band using an FFT. \*---------------------------------------------------------------------------*/ void aks_to_M2( float ak[], /* LPC's */ int order, MODEL *model, /* sinusoidal model parameters for this frame */ float E, /* energy term */ float *snr, /* signal to noise ratio for this frame in dB */ int dump /* true to dump sample to dump file */ ) { COMP Pw[FFT_DEC]; /* power spectrum */ int i,m; /* loop variables */ int am,bm; /* limits of current band */ float r; /* no. rads/bin */ float Em; /* energy in band */ float Am; /* spectral amplitude sample */ float signal, noise; r = TWO_PI/(FFT_DEC); /* Determine DFT of A(exp(jw)) --------------------------------------------*/ for(i=0; iL; m++) { am = floor((m - 0.5)*model->Wo/r + 0.5); bm = floor((m + 0.5)*model->Wo/r + 0.5); Em = 0.0; for(i=am; iA[m],2.0); noise += pow(model->A[m] - Am,2.0); model->A[m] = Am; } *snr = 10.0*log10(signal/noise); } /*---------------------------------------------------------------------------*\ FUNCTION....: encode_Wo() AUTHOR......: David Rowe DATE CREATED: 22/8/2010 Encodes Wo using a WO_LEVELS quantiser. \*---------------------------------------------------------------------------*/ int encode_Wo(float Wo) { int index; float Wo_min = TWO_PI/P_MAX; float Wo_max = TWO_PI/P_MIN; float norm; norm = (Wo - Wo_min)/(Wo_max - Wo_min); index = floor(WO_LEVELS * norm + 0.5); if (index < 0 ) index = 0; if (index > (WO_LEVELS-1)) index = WO_LEVELS-1; return index; } /*---------------------------------------------------------------------------*\ FUNCTION....: decode_Wo() AUTHOR......: David Rowe DATE CREATED: 22/8/2010 Decodes Wo using a WO_LEVELS quantiser. \*---------------------------------------------------------------------------*/ float decode_Wo(int index) { float Wo_min = TWO_PI/P_MAX; float Wo_max = TWO_PI/P_MIN; float step; float Wo; step = (Wo_max - Wo_min)/WO_LEVELS; Wo = Wo_min + step*(index); return Wo; } /*---------------------------------------------------------------------------*\ FUNCTION....: speech_to_uq_lsps() AUTHOR......: David Rowe DATE CREATED: 22/8/2010 Analyse a windowed frame of time domain speech to determine LPCs which are the converted to LSPs for quantisation and transmission over the channel. \*---------------------------------------------------------------------------*/ float speech_to_uq_lsps(float lsp[], float ak[], float Sn[], float w[], int order ) { int i, roots; float Wn[M]; float R[LPC_MAX+1]; float E; for(i=0; iA[1]) - 20.0*log10(tmp.A[1])); if (E1 > 6.0) return 1; else return 0; } /*---------------------------------------------------------------------------*\ FUNCTION....: apply_lpc_correction() AUTHOR......: David Rowe DATE CREATED: 22/8/2010 Apply first harmonic LPC correction at decoder. \*---------------------------------------------------------------------------*/ void apply_lpc_correction(MODEL *model, int lpc_correction) { if (lpc_correction) { if (model->Wo < (PI*150.0/4000)) { model->A[1] *= 0.032; } } } /*---------------------------------------------------------------------------*\ FUNCTION....: encode_energy() AUTHOR......: David Rowe DATE CREATED: 22/8/2010 Encodes LPC energy using an E_LEVELS quantiser. \*---------------------------------------------------------------------------*/ int encode_energy(float e) { int index; float e_min = E_MIN_DB; float e_max = E_MAX_DB; float norm; e = 10.0*log10(e); norm = (e - e_min)/(e_max - e_min); index = floor(E_LEVELS * norm + 0.5); if (index < 0 ) index = 0; if (index > (E_LEVELS-1)) index = E_LEVELS-1; return index; } /*---------------------------------------------------------------------------*\ FUNCTION....: decode_energy() AUTHOR......: David Rowe DATE CREATED: 22/8/2010 Decodes energy using a WO_BITS quantiser. \*---------------------------------------------------------------------------*/ float decode_energy(int index) { float e_min = E_MIN_DB; float e_max = E_MAX_DB; float step; float e; step = (e_max - e_min)/E_LEVELS; e = e_min + step*(index); e = pow(10.0,e/10.0); return e; } /*---------------------------------------------------------------------------*\ FUNCTION....: encode_amplitudes() AUTHOR......: David Rowe DATE CREATED: 22/8/2010 Time domain LPC is used model the amplitudes which are then converted to LSPs and quantised. So we don't actually encode the amplitudes directly, rather we derive an equivalent representation from the time domain speech. \*---------------------------------------------------------------------------*/ void encode_amplitudes(int lsp_indexes[], int *lpc_correction, int *energy_index, MODEL *model, float Sn[], float w[]) { float lsps[LPC_ORD]; float ak[LPC_ORD+1]; float e; e = speech_to_uq_lsps(lsps, ak, Sn, w, LPC_ORD); encode_lsps(lsp_indexes, lsps, LPC_ORD); *lpc_correction = need_lpc_correction(model, ak, e); *energy_index = encode_energy(e); } /*---------------------------------------------------------------------------*\ FUNCTION....: decode_amplitudes() AUTHOR......: David Rowe DATE CREATED: 22/8/2010 Given the amplitude quantiser indexes recovers the harmonic amplitudes. \*---------------------------------------------------------------------------*/ float decode_amplitudes(MODEL *model, float ak[], int lsp_indexes[], int lpc_correction, int energy_index ) { float lsps[LPC_ORD]; float e; float snr; decode_lsps(lsps, lsp_indexes, LPC_ORD); bw_expand_lsps(lsps, LPC_ORD); lsp_to_lpc(lsps, ak, LPC_ORD); e = decode_energy(energy_index); aks_to_M2(ak, LPC_ORD, model, e, &snr, 1); apply_lpc_correction(model, lpc_correction); return snr; }