mirror of
https://github.com/asterisk/asterisk.git
synced 2025-09-05 12:16:00 +00:00
Merged revisions 110880 via svnmerge from
https://origsvn.digium.com/svn/asterisk/branches/1.4 ................ r110880 | kpfleming | 2008-03-26 09:42:35 -0700 (Wed, 26 Mar 2008) | 10 lines Merged revisions 110869 via svnmerge from https://origsvn.digium.com/svn/asterisk/branches/1.2 ........ r110869 | kpfleming | 2008-03-26 08:53:46 -0700 (Wed, 26 Mar 2008) | 2 lines due to licensing restrictions, we cannot distribute the source code for iLBC encoding and decoding... so remove it, and add instructions on how the user can obtain it themselves ........ ................ git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@110881 65c4cc65-6c06-0410-ace0-fbb531ad65f3
This commit is contained in:
Kevin P. Fleming
@@ -1,619 +0,0 @@
|
||||
|
||||
/******************************************************************
|
||||
|
||||
iLBC Speech Coder ANSI-C Source Code
|
||||
|
||||
iLBC_decode.c
|
||||
|
||||
Copyright (C) The Internet Society (2004).
|
||||
All Rights Reserved.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "iLBC_define.h"
|
||||
#include "iLBC_decode.h"
|
||||
#include "StateConstructW.h"
|
||||
#include "LPCdecode.h"
|
||||
#include "iCBConstruct.h"
|
||||
#include "doCPLC.h"
|
||||
#include "helpfun.h"
|
||||
#include "constants.h"
|
||||
#include "packing.h"
|
||||
#include "string.h"
|
||||
#include "enhancer.h"
|
||||
#include "hpOutput.h"
|
||||
#include "syntFilter.h"
|
||||
|
||||
/*----------------------------------------------------------------*
|
||||
* Initiation of decoder instance.
|
||||
*---------------------------------------------------------------*/
|
||||
|
||||
short initDecode( /* (o) Number of decoded
|
||||
samples */
|
||||
iLBC_Dec_Inst_t *iLBCdec_inst, /* (i/o) Decoder instance */
|
||||
int mode, /* (i) frame size mode */
|
||||
int use_enhancer /* (i) 1 to use enhancer
|
||||
0 to run without
|
||||
enhancer */
|
||||
){
|
||||
int i;
|
||||
|
||||
iLBCdec_inst->mode = mode;
|
||||
|
||||
if (mode==30) {
|
||||
iLBCdec_inst->blockl = BLOCKL_30MS;
|
||||
iLBCdec_inst->nsub = NSUB_30MS;
|
||||
iLBCdec_inst->nasub = NASUB_30MS;
|
||||
iLBCdec_inst->lpc_n = LPC_N_30MS;
|
||||
|
||||
|
||||
iLBCdec_inst->no_of_bytes = NO_OF_BYTES_30MS;
|
||||
iLBCdec_inst->no_of_words = NO_OF_WORDS_30MS;
|
||||
iLBCdec_inst->state_short_len=STATE_SHORT_LEN_30MS;
|
||||
/* ULP init */
|
||||
iLBCdec_inst->ULP_inst=&ULP_30msTbl;
|
||||
}
|
||||
else if (mode==20) {
|
||||
iLBCdec_inst->blockl = BLOCKL_20MS;
|
||||
iLBCdec_inst->nsub = NSUB_20MS;
|
||||
iLBCdec_inst->nasub = NASUB_20MS;
|
||||
iLBCdec_inst->lpc_n = LPC_N_20MS;
|
||||
iLBCdec_inst->no_of_bytes = NO_OF_BYTES_20MS;
|
||||
iLBCdec_inst->no_of_words = NO_OF_WORDS_20MS;
|
||||
iLBCdec_inst->state_short_len=STATE_SHORT_LEN_20MS;
|
||||
/* ULP init */
|
||||
iLBCdec_inst->ULP_inst=&ULP_20msTbl;
|
||||
}
|
||||
else {
|
||||
exit(2);
|
||||
}
|
||||
|
||||
memset(iLBCdec_inst->syntMem, 0,
|
||||
LPC_FILTERORDER*sizeof(float));
|
||||
memcpy((*iLBCdec_inst).lsfdeqold, lsfmeanTbl,
|
||||
LPC_FILTERORDER*sizeof(float));
|
||||
|
||||
memset(iLBCdec_inst->old_syntdenum, 0,
|
||||
((LPC_FILTERORDER + 1)*NSUB_MAX)*sizeof(float));
|
||||
for (i=0; i<NSUB_MAX; i++)
|
||||
iLBCdec_inst->old_syntdenum[i*(LPC_FILTERORDER+1)]=1.0;
|
||||
|
||||
iLBCdec_inst->last_lag = 20;
|
||||
|
||||
iLBCdec_inst->prevLag = 120;
|
||||
iLBCdec_inst->per = 0.0;
|
||||
iLBCdec_inst->consPLICount = 0;
|
||||
iLBCdec_inst->prevPLI = 0;
|
||||
iLBCdec_inst->prevLpc[0] = 1.0;
|
||||
memset(iLBCdec_inst->prevLpc+1,0,
|
||||
LPC_FILTERORDER*sizeof(float));
|
||||
memset(iLBCdec_inst->prevResidual, 0, BLOCKL_MAX*sizeof(float));
|
||||
iLBCdec_inst->seed=777;
|
||||
|
||||
memset(iLBCdec_inst->hpomem, 0, 4*sizeof(float));
|
||||
|
||||
iLBCdec_inst->use_enhancer = use_enhancer;
|
||||
memset(iLBCdec_inst->enh_buf, 0, ENH_BUFL*sizeof(float));
|
||||
for (i=0;i<ENH_NBLOCKS_TOT;i++)
|
||||
iLBCdec_inst->enh_period[i]=(float)40.0;
|
||||
|
||||
iLBCdec_inst->prev_enh_pl = 0;
|
||||
|
||||
return (iLBCdec_inst->blockl);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------*
|
||||
* frame residual decoder function (subrutine to iLBC_decode)
|
||||
*---------------------------------------------------------------*/
|
||||
|
||||
static void Decode(
|
||||
iLBC_Dec_Inst_t *iLBCdec_inst, /* (i/o) the decoder state
|
||||
structure */
|
||||
float *decresidual, /* (o) decoded residual frame */
|
||||
int start, /* (i) location of start
|
||||
state */
|
||||
int idxForMax, /* (i) codebook index for the
|
||||
maximum value */
|
||||
int *idxVec, /* (i) codebook indexes for the
|
||||
samples in the start
|
||||
state */
|
||||
float *syntdenum, /* (i) the decoded synthesis
|
||||
filter coefficients */
|
||||
int *cb_index, /* (i) the indexes for the
|
||||
adaptive codebook */
|
||||
int *gain_index, /* (i) the indexes for the
|
||||
corresponding gains */
|
||||
int *extra_cb_index, /* (i) the indexes for the
|
||||
adaptive codebook part
|
||||
of start state */
|
||||
int *extra_gain_index, /* (i) the indexes for the
|
||||
corresponding gains */
|
||||
int state_first /* (i) 1 if non adaptive part
|
||||
of start state comes
|
||||
first 0 if that part
|
||||
comes last */
|
||||
){
|
||||
float reverseDecresidual[BLOCKL_MAX], mem[CB_MEML];
|
||||
int k, meml_gotten, Nfor, Nback, i;
|
||||
int diff, start_pos;
|
||||
int subcount, subframe;
|
||||
|
||||
diff = STATE_LEN - iLBCdec_inst->state_short_len;
|
||||
|
||||
if (state_first == 1) {
|
||||
start_pos = (start-1)*SUBL;
|
||||
} else {
|
||||
start_pos = (start-1)*SUBL + diff;
|
||||
}
|
||||
|
||||
/* decode scalar part of start state */
|
||||
|
||||
StateConstructW(idxForMax, idxVec,
|
||||
&syntdenum[(start-1)*(LPC_FILTERORDER+1)],
|
||||
&decresidual[start_pos], iLBCdec_inst->state_short_len);
|
||||
|
||||
|
||||
if (state_first) { /* put adaptive part in the end */
|
||||
|
||||
|
||||
|
||||
/* setup memory */
|
||||
|
||||
memset(mem, 0,
|
||||
(CB_MEML-iLBCdec_inst->state_short_len)*sizeof(float));
|
||||
memcpy(mem+CB_MEML-iLBCdec_inst->state_short_len,
|
||||
decresidual+start_pos,
|
||||
iLBCdec_inst->state_short_len*sizeof(float));
|
||||
|
||||
/* construct decoded vector */
|
||||
|
||||
iCBConstruct(
|
||||
&decresidual[start_pos+iLBCdec_inst->state_short_len],
|
||||
extra_cb_index, extra_gain_index, mem+CB_MEML-stMemLTbl,
|
||||
stMemLTbl, diff, CB_NSTAGES);
|
||||
|
||||
}
|
||||
else {/* put adaptive part in the beginning */
|
||||
|
||||
/* create reversed vectors for prediction */
|
||||
|
||||
for (k=0; k<diff; k++) {
|
||||
reverseDecresidual[k] =
|
||||
decresidual[(start+1)*SUBL-1-
|
||||
(k+iLBCdec_inst->state_short_len)];
|
||||
}
|
||||
|
||||
/* setup memory */
|
||||
|
||||
meml_gotten = iLBCdec_inst->state_short_len;
|
||||
for (k=0; k<meml_gotten; k++){
|
||||
mem[CB_MEML-1-k] = decresidual[start_pos + k];
|
||||
}
|
||||
memset(mem, 0, (CB_MEML-k)*sizeof(float));
|
||||
|
||||
/* construct decoded vector */
|
||||
|
||||
iCBConstruct(reverseDecresidual, extra_cb_index,
|
||||
extra_gain_index, mem+CB_MEML-stMemLTbl, stMemLTbl,
|
||||
diff, CB_NSTAGES);
|
||||
|
||||
/* get decoded residual from reversed vector */
|
||||
|
||||
for (k=0; k<diff; k++) {
|
||||
decresidual[start_pos-1-k] = reverseDecresidual[k];
|
||||
}
|
||||
}
|
||||
|
||||
/* counter for predicted sub-frames */
|
||||
|
||||
subcount=0;
|
||||
|
||||
/* forward prediction of sub-frames */
|
||||
|
||||
Nfor = iLBCdec_inst->nsub-start-1;
|
||||
|
||||
|
||||
|
||||
if ( Nfor > 0 ){
|
||||
|
||||
/* setup memory */
|
||||
|
||||
memset(mem, 0, (CB_MEML-STATE_LEN)*sizeof(float));
|
||||
memcpy(mem+CB_MEML-STATE_LEN, decresidual+(start-1)*SUBL,
|
||||
STATE_LEN*sizeof(float));
|
||||
|
||||
/* loop over sub-frames to encode */
|
||||
|
||||
for (subframe=0; subframe<Nfor; subframe++) {
|
||||
|
||||
/* construct decoded vector */
|
||||
|
||||
iCBConstruct(&decresidual[(start+1+subframe)*SUBL],
|
||||
cb_index+subcount*CB_NSTAGES,
|
||||
gain_index+subcount*CB_NSTAGES,
|
||||
mem+CB_MEML-memLfTbl[subcount],
|
||||
memLfTbl[subcount], SUBL, CB_NSTAGES);
|
||||
|
||||
/* update memory */
|
||||
|
||||
memmove(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
|
||||
memcpy(mem+CB_MEML-SUBL,
|
||||
&decresidual[(start+1+subframe)*SUBL],
|
||||
SUBL*sizeof(float));
|
||||
|
||||
subcount++;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* backward prediction of sub-frames */
|
||||
|
||||
Nback = start-1;
|
||||
|
||||
if ( Nback > 0 ) {
|
||||
|
||||
/* setup memory */
|
||||
|
||||
meml_gotten = SUBL*(iLBCdec_inst->nsub+1-start);
|
||||
|
||||
if ( meml_gotten > CB_MEML ) {
|
||||
meml_gotten=CB_MEML;
|
||||
}
|
||||
for (k=0; k<meml_gotten; k++) {
|
||||
mem[CB_MEML-1-k] = decresidual[(start-1)*SUBL + k];
|
||||
}
|
||||
memset(mem, 0, (CB_MEML-k)*sizeof(float));
|
||||
|
||||
/* loop over subframes to decode */
|
||||
|
||||
|
||||
|
||||
for (subframe=0; subframe<Nback; subframe++) {
|
||||
|
||||
/* construct decoded vector */
|
||||
|
||||
iCBConstruct(&reverseDecresidual[subframe*SUBL],
|
||||
cb_index+subcount*CB_NSTAGES,
|
||||
gain_index+subcount*CB_NSTAGES,
|
||||
mem+CB_MEML-memLfTbl[subcount], memLfTbl[subcount],
|
||||
SUBL, CB_NSTAGES);
|
||||
|
||||
/* update memory */
|
||||
|
||||
memmove(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
|
||||
memcpy(mem+CB_MEML-SUBL,
|
||||
&reverseDecresidual[subframe*SUBL],
|
||||
SUBL*sizeof(float));
|
||||
|
||||
subcount++;
|
||||
}
|
||||
|
||||
/* get decoded residual from reversed vector */
|
||||
|
||||
for (i=0; i<SUBL*Nback; i++)
|
||||
decresidual[SUBL*Nback - i - 1] =
|
||||
reverseDecresidual[i];
|
||||
}
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------*
|
||||
* main decoder function
|
||||
*---------------------------------------------------------------*/
|
||||
|
||||
void iLBC_decode(
|
||||
float *decblock, /* (o) decoded signal block */
|
||||
unsigned char *bytes, /* (i) encoded signal bits */
|
||||
iLBC_Dec_Inst_t *iLBCdec_inst, /* (i/o) the decoder state
|
||||
structure */
|
||||
int mode /* (i) 0: bad packet, PLC,
|
||||
1: normal */
|
||||
){
|
||||
float data[BLOCKL_MAX];
|
||||
float lsfdeq[LPC_FILTERORDER*LPC_N_MAX];
|
||||
float PLCresidual[BLOCKL_MAX], PLClpc[LPC_FILTERORDER + 1];
|
||||
float zeros[BLOCKL_MAX], one[LPC_FILTERORDER + 1];
|
||||
int k, i, start, idxForMax, pos, lastpart, ulp;
|
||||
int lag, ilag;
|
||||
float cc, maxcc;
|
||||
int idxVec[STATE_LEN];
|
||||
int check;
|
||||
int gain_index[NASUB_MAX*CB_NSTAGES],
|
||||
extra_gain_index[CB_NSTAGES];
|
||||
int cb_index[CB_NSTAGES*NASUB_MAX], extra_cb_index[CB_NSTAGES];
|
||||
int lsf_i[LSF_NSPLIT*LPC_N_MAX];
|
||||
int state_first;
|
||||
|
||||
|
||||
int last_bit;
|
||||
unsigned char *pbytes;
|
||||
float weightdenum[(LPC_FILTERORDER + 1)*NSUB_MAX];
|
||||
int order_plus_one;
|
||||
float syntdenum[NSUB_MAX*(LPC_FILTERORDER+1)];
|
||||
float decresidual[BLOCKL_MAX];
|
||||
|
||||
if (mode>0) { /* the data are good */
|
||||
|
||||
/* decode data */
|
||||
|
||||
pbytes=bytes;
|
||||
pos=0;
|
||||
|
||||
/* Set everything to zero before decoding */
|
||||
|
||||
for (k=0; k<LSF_NSPLIT*LPC_N_MAX; k++) {
|
||||
lsf_i[k]=0;
|
||||
}
|
||||
start=0;
|
||||
state_first=0;
|
||||
idxForMax=0;
|
||||
for (k=0; k<iLBCdec_inst->state_short_len; k++) {
|
||||
idxVec[k]=0;
|
||||
}
|
||||
for (k=0; k<CB_NSTAGES; k++) {
|
||||
extra_cb_index[k]=0;
|
||||
}
|
||||
for (k=0; k<CB_NSTAGES; k++) {
|
||||
extra_gain_index[k]=0;
|
||||
}
|
||||
for (i=0; i<iLBCdec_inst->nasub; i++) {
|
||||
for (k=0; k<CB_NSTAGES; k++) {
|
||||
cb_index[i*CB_NSTAGES+k]=0;
|
||||
}
|
||||
}
|
||||
for (i=0; i<iLBCdec_inst->nasub; i++) {
|
||||
for (k=0; k<CB_NSTAGES; k++) {
|
||||
gain_index[i*CB_NSTAGES+k]=0;
|
||||
}
|
||||
}
|
||||
|
||||
/* loop over ULP classes */
|
||||
|
||||
for (ulp=0; ulp<3; ulp++) {
|
||||
|
||||
/* LSF */
|
||||
for (k=0; k<LSF_NSPLIT*iLBCdec_inst->lpc_n; k++){
|
||||
unpack( &pbytes, &lastpart,
|
||||
iLBCdec_inst->ULP_inst->lsf_bits[k][ulp], &pos);
|
||||
packcombine(&lsf_i[k], lastpart,
|
||||
iLBCdec_inst->ULP_inst->lsf_bits[k][ulp]);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* Start block info */
|
||||
|
||||
unpack( &pbytes, &lastpart,
|
||||
iLBCdec_inst->ULP_inst->start_bits[ulp], &pos);
|
||||
packcombine(&start, lastpart,
|
||||
iLBCdec_inst->ULP_inst->start_bits[ulp]);
|
||||
|
||||
unpack( &pbytes, &lastpart,
|
||||
iLBCdec_inst->ULP_inst->startfirst_bits[ulp], &pos);
|
||||
packcombine(&state_first, lastpart,
|
||||
iLBCdec_inst->ULP_inst->startfirst_bits[ulp]);
|
||||
|
||||
unpack( &pbytes, &lastpart,
|
||||
iLBCdec_inst->ULP_inst->scale_bits[ulp], &pos);
|
||||
packcombine(&idxForMax, lastpart,
|
||||
iLBCdec_inst->ULP_inst->scale_bits[ulp]);
|
||||
|
||||
for (k=0; k<iLBCdec_inst->state_short_len; k++) {
|
||||
unpack( &pbytes, &lastpart,
|
||||
iLBCdec_inst->ULP_inst->state_bits[ulp], &pos);
|
||||
packcombine(idxVec+k, lastpart,
|
||||
iLBCdec_inst->ULP_inst->state_bits[ulp]);
|
||||
}
|
||||
|
||||
/* 23/22 (20ms/30ms) sample block */
|
||||
|
||||
for (k=0; k<CB_NSTAGES; k++) {
|
||||
unpack( &pbytes, &lastpart,
|
||||
iLBCdec_inst->ULP_inst->extra_cb_index[k][ulp],
|
||||
&pos);
|
||||
packcombine(extra_cb_index+k, lastpart,
|
||||
iLBCdec_inst->ULP_inst->extra_cb_index[k][ulp]);
|
||||
}
|
||||
for (k=0; k<CB_NSTAGES; k++) {
|
||||
unpack( &pbytes, &lastpart,
|
||||
iLBCdec_inst->ULP_inst->extra_cb_gain[k][ulp],
|
||||
&pos);
|
||||
packcombine(extra_gain_index+k, lastpart,
|
||||
iLBCdec_inst->ULP_inst->extra_cb_gain[k][ulp]);
|
||||
}
|
||||
|
||||
/* The two/four (20ms/30ms) 40 sample sub-blocks */
|
||||
|
||||
for (i=0; i<iLBCdec_inst->nasub; i++) {
|
||||
for (k=0; k<CB_NSTAGES; k++) {
|
||||
unpack( &pbytes, &lastpart,
|
||||
iLBCdec_inst->ULP_inst->cb_index[i][k][ulp],
|
||||
&pos);
|
||||
packcombine(cb_index+i*CB_NSTAGES+k, lastpart,
|
||||
iLBCdec_inst->ULP_inst->cb_index[i][k][ulp]);
|
||||
}
|
||||
}
|
||||
|
||||
for (i=0; i<iLBCdec_inst->nasub; i++) {
|
||||
|
||||
|
||||
for (k=0; k<CB_NSTAGES; k++) {
|
||||
unpack( &pbytes, &lastpart,
|
||||
|
||||
iLBCdec_inst->ULP_inst->cb_gain[i][k][ulp],
|
||||
&pos);
|
||||
packcombine(gain_index+i*CB_NSTAGES+k, lastpart,
|
||||
iLBCdec_inst->ULP_inst->cb_gain[i][k][ulp]);
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Extract last bit. If it is 1 this indicates an
|
||||
empty/lost frame */
|
||||
unpack( &pbytes, &last_bit, 1, &pos);
|
||||
|
||||
/* Check for bit errors or empty/lost frames */
|
||||
if (start<1)
|
||||
mode = 0;
|
||||
if (iLBCdec_inst->mode==20 && start>3)
|
||||
mode = 0;
|
||||
if (iLBCdec_inst->mode==30 && start>5)
|
||||
mode = 0;
|
||||
if (last_bit==1)
|
||||
mode = 0;
|
||||
|
||||
if (mode==1) { /* No bit errors was detected,
|
||||
continue decoding */
|
||||
|
||||
/* adjust index */
|
||||
index_conv_dec(cb_index);
|
||||
|
||||
/* decode the lsf */
|
||||
|
||||
SimplelsfDEQ(lsfdeq, lsf_i, iLBCdec_inst->lpc_n);
|
||||
check=LSF_check(lsfdeq, LPC_FILTERORDER,
|
||||
iLBCdec_inst->lpc_n);
|
||||
DecoderInterpolateLSF(syntdenum, weightdenum,
|
||||
lsfdeq, LPC_FILTERORDER, iLBCdec_inst);
|
||||
|
||||
Decode(iLBCdec_inst, decresidual, start, idxForMax,
|
||||
idxVec, syntdenum, cb_index, gain_index,
|
||||
extra_cb_index, extra_gain_index,
|
||||
state_first);
|
||||
|
||||
/* preparing the plc for a future loss! */
|
||||
|
||||
doThePLC(PLCresidual, PLClpc, 0, decresidual,
|
||||
syntdenum +
|
||||
(LPC_FILTERORDER + 1)*(iLBCdec_inst->nsub - 1),
|
||||
(*iLBCdec_inst).last_lag, iLBCdec_inst);
|
||||
|
||||
|
||||
memcpy(decresidual, PLCresidual,
|
||||
iLBCdec_inst->blockl*sizeof(float));
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
if (mode == 0) {
|
||||
/* the data is bad (either a PLC call
|
||||
* was made or a severe bit error was detected)
|
||||
*/
|
||||
|
||||
/* packet loss conceal */
|
||||
|
||||
memset(zeros, 0, BLOCKL_MAX*sizeof(float));
|
||||
|
||||
one[0] = 1;
|
||||
memset(one+1, 0, LPC_FILTERORDER*sizeof(float));
|
||||
|
||||
start=0;
|
||||
|
||||
doThePLC(PLCresidual, PLClpc, 1, zeros, one,
|
||||
(*iLBCdec_inst).last_lag, iLBCdec_inst);
|
||||
memcpy(decresidual, PLCresidual,
|
||||
iLBCdec_inst->blockl*sizeof(float));
|
||||
|
||||
order_plus_one = LPC_FILTERORDER + 1;
|
||||
for (i = 0; i < iLBCdec_inst->nsub; i++) {
|
||||
memcpy(syntdenum+(i*order_plus_one), PLClpc,
|
||||
order_plus_one*sizeof(float));
|
||||
}
|
||||
}
|
||||
|
||||
if (iLBCdec_inst->use_enhancer == 1) {
|
||||
|
||||
/* post filtering */
|
||||
|
||||
iLBCdec_inst->last_lag =
|
||||
enhancerInterface(data, decresidual, iLBCdec_inst);
|
||||
|
||||
/* synthesis filtering */
|
||||
|
||||
if (iLBCdec_inst->mode==20) {
|
||||
/* Enhancer has 40 samples delay */
|
||||
i=0;
|
||||
syntFilter(data + i*SUBL,
|
||||
iLBCdec_inst->old_syntdenum +
|
||||
(i+iLBCdec_inst->nsub-1)*(LPC_FILTERORDER+1),
|
||||
SUBL, iLBCdec_inst->syntMem);
|
||||
for (i=1; i < iLBCdec_inst->nsub; i++) {
|
||||
syntFilter(data + i*SUBL,
|
||||
syntdenum + (i-1)*(LPC_FILTERORDER+1),
|
||||
SUBL, iLBCdec_inst->syntMem);
|
||||
}
|
||||
} else if (iLBCdec_inst->mode==30) {
|
||||
/* Enhancer has 80 samples delay */
|
||||
for (i=0; i < 2; i++) {
|
||||
syntFilter(data + i*SUBL,
|
||||
|
||||
|
||||
iLBCdec_inst->old_syntdenum +
|
||||
(i+iLBCdec_inst->nsub-2)*(LPC_FILTERORDER+1),
|
||||
SUBL, iLBCdec_inst->syntMem);
|
||||
}
|
||||
for (i=2; i < iLBCdec_inst->nsub; i++) {
|
||||
syntFilter(data + i*SUBL,
|
||||
syntdenum + (i-2)*(LPC_FILTERORDER+1), SUBL,
|
||||
iLBCdec_inst->syntMem);
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
/* Find last lag */
|
||||
lag = 20;
|
||||
maxcc = xCorrCoef(&decresidual[BLOCKL_MAX-ENH_BLOCKL],
|
||||
&decresidual[BLOCKL_MAX-ENH_BLOCKL-lag], ENH_BLOCKL);
|
||||
|
||||
for (ilag=21; ilag<120; ilag++) {
|
||||
cc = xCorrCoef(&decresidual[BLOCKL_MAX-ENH_BLOCKL],
|
||||
&decresidual[BLOCKL_MAX-ENH_BLOCKL-ilag],
|
||||
ENH_BLOCKL);
|
||||
|
||||
if (cc > maxcc) {
|
||||
maxcc = cc;
|
||||
lag = ilag;
|
||||
}
|
||||
}
|
||||
iLBCdec_inst->last_lag = lag;
|
||||
|
||||
/* copy data and run synthesis filter */
|
||||
|
||||
memcpy(data, decresidual,
|
||||
iLBCdec_inst->blockl*sizeof(float));
|
||||
for (i=0; i < iLBCdec_inst->nsub; i++) {
|
||||
syntFilter(data + i*SUBL,
|
||||
syntdenum + i*(LPC_FILTERORDER+1), SUBL,
|
||||
iLBCdec_inst->syntMem);
|
||||
}
|
||||
}
|
||||
|
||||
/* high pass filtering on output if desired, otherwise
|
||||
copy to out */
|
||||
|
||||
hpOutput(data, iLBCdec_inst->blockl,
|
||||
decblock,iLBCdec_inst->hpomem);
|
||||
|
||||
/* memcpy(decblock,data,iLBCdec_inst->blockl*sizeof(float));*/
|
||||
|
||||
memcpy(iLBCdec_inst->old_syntdenum, syntdenum,
|
||||
|
||||
iLBCdec_inst->nsub*(LPC_FILTERORDER+1)*sizeof(float));
|
||||
|
||||
iLBCdec_inst->prev_enh_pl=0;
|
||||
|
||||
|
||||
|
||||
if (mode==0) { /* PLC was used */
|
||||
iLBCdec_inst->prev_enh_pl=1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user