diff options
Diffstat (limited to 'trunk/codecs/ilbc/iLBC_encode.c')
-rw-r--r-- | trunk/codecs/ilbc/iLBC_encode.c | 514 |
1 files changed, 514 insertions, 0 deletions
diff --git a/trunk/codecs/ilbc/iLBC_encode.c b/trunk/codecs/ilbc/iLBC_encode.c new file mode 100644 index 000000000..bd1496498 --- /dev/null +++ b/trunk/codecs/ilbc/iLBC_encode.c @@ -0,0 +1,514 @@ + +/****************************************************************** + + iLBC Speech Coder ANSI-C Source Code + + iLBC_encode.c + + Copyright (C) The Internet Society (2004). + All Rights Reserved. + +******************************************************************/ + +#include <math.h> +#include <stdlib.h> +#include <string.h> + +#include "iLBC_define.h" +#include "iLBC_encode.h" +#include "LPCencode.h" +#include "FrameClassify.h" +#include "StateSearchW.h" +#include "StateConstructW.h" +#include "helpfun.h" +#include "constants.h" +#include "packing.h" +#include "iCBSearch.h" +#include "iCBConstruct.h" +#include "hpInput.h" +#include "anaFilter.h" +#include "syntFilter.h" + +/*----------------------------------------------------------------* + * Initiation of encoder instance. + *---------------------------------------------------------------*/ + +short initEncode( /* (o) Number of bytes + encoded */ + iLBC_Enc_Inst_t *iLBCenc_inst, /* (i/o) Encoder instance */ + int mode /* (i) frame size mode */ +){ + iLBCenc_inst->mode = mode; + if (mode==30) { + iLBCenc_inst->blockl = BLOCKL_30MS; + iLBCenc_inst->nsub = NSUB_30MS; + + + iLBCenc_inst->nasub = NASUB_30MS; + iLBCenc_inst->lpc_n = LPC_N_30MS; + iLBCenc_inst->no_of_bytes = NO_OF_BYTES_30MS; + iLBCenc_inst->no_of_words = NO_OF_WORDS_30MS; + iLBCenc_inst->state_short_len=STATE_SHORT_LEN_30MS; + /* ULP init */ + iLBCenc_inst->ULP_inst=&ULP_30msTbl; + } + else if (mode==20) { + iLBCenc_inst->blockl = BLOCKL_20MS; + iLBCenc_inst->nsub = NSUB_20MS; + iLBCenc_inst->nasub = NASUB_20MS; + iLBCenc_inst->lpc_n = LPC_N_20MS; + iLBCenc_inst->no_of_bytes = NO_OF_BYTES_20MS; + iLBCenc_inst->no_of_words = NO_OF_WORDS_20MS; + iLBCenc_inst->state_short_len=STATE_SHORT_LEN_20MS; + /* ULP init */ + iLBCenc_inst->ULP_inst=&ULP_20msTbl; + } + else { + exit(2); + } + + memset((*iLBCenc_inst).anaMem, 0, + LPC_FILTERORDER*sizeof(float)); + memcpy((*iLBCenc_inst).lsfold, lsfmeanTbl, + LPC_FILTERORDER*sizeof(float)); + memcpy((*iLBCenc_inst).lsfdeqold, lsfmeanTbl, + LPC_FILTERORDER*sizeof(float)); + memset((*iLBCenc_inst).lpc_buffer, 0, + (LPC_LOOKBACK+BLOCKL_MAX)*sizeof(float)); + memset((*iLBCenc_inst).hpimem, 0, 4*sizeof(float)); + + return (iLBCenc_inst->no_of_bytes); +} + +/*----------------------------------------------------------------* + * main encoder function + *---------------------------------------------------------------*/ + +void iLBC_encode( + unsigned char *bytes, /* (o) encoded data bits iLBC */ + float *block, /* (o) speech vector to + encode */ + iLBC_Enc_Inst_t *iLBCenc_inst /* (i/o) the general encoder + state */ +){ + + float data[BLOCKL_MAX]; + float residual[BLOCKL_MAX], reverseResidual[BLOCKL_MAX]; + + int start, idxForMax, idxVec[STATE_LEN]; + float reverseDecresidual[BLOCKL_MAX], mem[CB_MEML]; + int n, k, meml_gotten, Nfor, Nback, i, pos; + + + int gain_index[CB_NSTAGES*NASUB_MAX], + 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]; + unsigned char *pbytes; + int diff, start_pos, state_first; + float en1, en2; + int index, ulp, firstpart; + int subcount, subframe; + float weightState[LPC_FILTERORDER]; + float syntdenum[NSUB_MAX*(LPC_FILTERORDER+1)]; + float weightdenum[NSUB_MAX*(LPC_FILTERORDER+1)]; + float decresidual[BLOCKL_MAX]; + + /* high pass filtering of input signal if such is not done + prior to calling this function */ + + hpInput(block, iLBCenc_inst->blockl, + data, (*iLBCenc_inst).hpimem); + + /* otherwise simply copy */ + + /*memcpy(data,block,iLBCenc_inst->blockl*sizeof(float));*/ + + /* LPC of hp filtered input data */ + + LPCencode(syntdenum, weightdenum, lsf_i, data, iLBCenc_inst); + + + /* inverse filter to get residual */ + + for (n=0; n<iLBCenc_inst->nsub; n++) { + anaFilter(&data[n*SUBL], &syntdenum[n*(LPC_FILTERORDER+1)], + SUBL, &residual[n*SUBL], iLBCenc_inst->anaMem); + } + + /* find state location */ + + start = FrameClassify(iLBCenc_inst, residual); + + /* check if state should be in first or last part of the + two subframes */ + + diff = STATE_LEN - iLBCenc_inst->state_short_len; + en1 = 0; + index = (start-1)*SUBL; + for (i = 0; i < iLBCenc_inst->state_short_len; i++) { + en1 += residual[index+i]*residual[index+i]; + } + en2 = 0; + index = (start-1)*SUBL+diff; + for (i = 0; i < iLBCenc_inst->state_short_len; i++) { + en2 += residual[index+i]*residual[index+i]; + } + + + + + if (en1 > en2) { + state_first = 1; + start_pos = (start-1)*SUBL; + } else { + state_first = 0; + start_pos = (start-1)*SUBL + diff; + } + + /* scalar quantization of state */ + + StateSearchW(iLBCenc_inst, &residual[start_pos], + &syntdenum[(start-1)*(LPC_FILTERORDER+1)], + &weightdenum[(start-1)*(LPC_FILTERORDER+1)], &idxForMax, + idxVec, iLBCenc_inst->state_short_len, state_first); + + StateConstructW(idxForMax, idxVec, + &syntdenum[(start-1)*(LPC_FILTERORDER+1)], + &decresidual[start_pos], iLBCenc_inst->state_short_len); + + /* predictive quantization in state */ + + if (state_first) { /* put adaptive part in the end */ + + /* setup memory */ + + memset(mem, 0, + (CB_MEML-iLBCenc_inst->state_short_len)*sizeof(float)); + memcpy(mem+CB_MEML-iLBCenc_inst->state_short_len, + decresidual+start_pos, + iLBCenc_inst->state_short_len*sizeof(float)); + memset(weightState, 0, LPC_FILTERORDER*sizeof(float)); + + /* encode sub-frames */ + + iCBSearch(iLBCenc_inst, extra_cb_index, extra_gain_index, + &residual[start_pos+iLBCenc_inst->state_short_len], + mem+CB_MEML-stMemLTbl, + stMemLTbl, diff, CB_NSTAGES, + &weightdenum[start*(LPC_FILTERORDER+1)], + weightState, 0); + + /* construct decoded vector */ + + iCBConstruct( + &decresidual[start_pos+iLBCenc_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++) { + reverseResidual[k] = residual[(start+1)*SUBL-1 + -(k+iLBCenc_inst->state_short_len)]; + } + + /* setup memory */ + + meml_gotten = iLBCenc_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)); + memset(weightState, 0, LPC_FILTERORDER*sizeof(float)); + + /* encode sub-frames */ + + iCBSearch(iLBCenc_inst, extra_cb_index, extra_gain_index, + reverseResidual, mem+CB_MEML-stMemLTbl, stMemLTbl, + diff, CB_NSTAGES, + &weightdenum[(start-1)*(LPC_FILTERORDER+1)], + weightState, 0); + + /* 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 = iLBCenc_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)); + memset(weightState, 0, LPC_FILTERORDER*sizeof(float)); + + + + /* loop over sub-frames to encode */ + + for (subframe=0; subframe<Nfor; subframe++) { + + /* encode sub-frame */ + + iCBSearch(iLBCenc_inst, cb_index+subcount*CB_NSTAGES, + gain_index+subcount*CB_NSTAGES, + &residual[(start+1+subframe)*SUBL], + mem+CB_MEML-memLfTbl[subcount], + memLfTbl[subcount], SUBL, CB_NSTAGES, + &weightdenum[(start+1+subframe)* + (LPC_FILTERORDER+1)], + weightState, subcount+1); + + /* 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)); + memset(weightState, 0, LPC_FILTERORDER*sizeof(float)); + + subcount++; + } + } + + + /* backward prediction of sub-frames */ + + Nback = start-1; + + + if ( Nback > 0 ) { + + /* create reverse order vectors */ + + for (n=0; n<Nback; n++) { + for (k=0; k<SUBL; k++) { + reverseResidual[n*SUBL+k] = + residual[(start-1)*SUBL-1-n*SUBL-k]; + reverseDecresidual[n*SUBL+k] = + decresidual[(start-1)*SUBL-1-n*SUBL-k]; + } + } + + + + /* setup memory */ + + meml_gotten = SUBL*(iLBCenc_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)); + memset(weightState, 0, LPC_FILTERORDER*sizeof(float)); + + /* loop over sub-frames to encode */ + + for (subframe=0; subframe<Nback; subframe++) { + + /* encode sub-frame */ + + iCBSearch(iLBCenc_inst, cb_index+subcount*CB_NSTAGES, + gain_index+subcount*CB_NSTAGES, + &reverseResidual[subframe*SUBL], + mem+CB_MEML-memLfTbl[subcount], + memLfTbl[subcount], SUBL, CB_NSTAGES, + &weightdenum[(start-2-subframe)* + (LPC_FILTERORDER+1)], + weightState, subcount+1); + + /* 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)); + memset(weightState, 0, LPC_FILTERORDER*sizeof(float)); + + subcount++; + + } + + /* get decoded residual from reversed vector */ + + for (i=0; i<SUBL*Nback; i++) { + decresidual[SUBL*Nback - i - 1] = + + + reverseDecresidual[i]; + } + } + /* end encoding part */ + + /* adjust index */ + index_conv_enc(cb_index); + + /* pack bytes */ + + pbytes=bytes; + pos=0; + + /* loop over the 3 ULP classes */ + + for (ulp=0; ulp<3; ulp++) { + + /* LSF */ + for (k=0; k<LSF_NSPLIT*iLBCenc_inst->lpc_n; k++) { + packsplit(&lsf_i[k], &firstpart, &lsf_i[k], + iLBCenc_inst->ULP_inst->lsf_bits[k][ulp], + iLBCenc_inst->ULP_inst->lsf_bits[k][ulp]+ + iLBCenc_inst->ULP_inst->lsf_bits[k][ulp+1]+ + iLBCenc_inst->ULP_inst->lsf_bits[k][ulp+2]); + dopack( &pbytes, firstpart, + iLBCenc_inst->ULP_inst->lsf_bits[k][ulp], &pos); + } + + /* Start block info */ + + packsplit(&start, &firstpart, &start, + iLBCenc_inst->ULP_inst->start_bits[ulp], + iLBCenc_inst->ULP_inst->start_bits[ulp]+ + iLBCenc_inst->ULP_inst->start_bits[ulp+1]+ + iLBCenc_inst->ULP_inst->start_bits[ulp+2]); + dopack( &pbytes, firstpart, + iLBCenc_inst->ULP_inst->start_bits[ulp], &pos); + + packsplit(&state_first, &firstpart, &state_first, + iLBCenc_inst->ULP_inst->startfirst_bits[ulp], + iLBCenc_inst->ULP_inst->startfirst_bits[ulp]+ + iLBCenc_inst->ULP_inst->startfirst_bits[ulp+1]+ + iLBCenc_inst->ULP_inst->startfirst_bits[ulp+2]); + dopack( &pbytes, firstpart, + iLBCenc_inst->ULP_inst->startfirst_bits[ulp], &pos); + + packsplit(&idxForMax, &firstpart, &idxForMax, + iLBCenc_inst->ULP_inst->scale_bits[ulp], + iLBCenc_inst->ULP_inst->scale_bits[ulp]+ + iLBCenc_inst->ULP_inst->scale_bits[ulp+1]+ + iLBCenc_inst->ULP_inst->scale_bits[ulp+2]); + dopack( &pbytes, firstpart, + iLBCenc_inst->ULP_inst->scale_bits[ulp], &pos); + + + + for (k=0; k<iLBCenc_inst->state_short_len; k++) { + packsplit(idxVec+k, &firstpart, idxVec+k, + iLBCenc_inst->ULP_inst->state_bits[ulp], + iLBCenc_inst->ULP_inst->state_bits[ulp]+ + iLBCenc_inst->ULP_inst->state_bits[ulp+1]+ + iLBCenc_inst->ULP_inst->state_bits[ulp+2]); + dopack( &pbytes, firstpart, + iLBCenc_inst->ULP_inst->state_bits[ulp], &pos); + } + + /* 23/22 (20ms/30ms) sample block */ + + for (k=0;k<CB_NSTAGES;k++) { + packsplit(extra_cb_index+k, &firstpart, + extra_cb_index+k, + iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp], + iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp]+ + iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp+1]+ + iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp+2]); + dopack( &pbytes, firstpart, + iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp], + &pos); + } + + for (k=0;k<CB_NSTAGES;k++) { + packsplit(extra_gain_index+k, &firstpart, + extra_gain_index+k, + iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp], + iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp]+ + iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp+1]+ + iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp+2]); + dopack( &pbytes, firstpart, + iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp], + &pos); + } + + /* The two/four (20ms/30ms) 40 sample sub-blocks */ + + for (i=0; i<iLBCenc_inst->nasub; i++) { + for (k=0; k<CB_NSTAGES; k++) { + packsplit(cb_index+i*CB_NSTAGES+k, &firstpart, + cb_index+i*CB_NSTAGES+k, + iLBCenc_inst->ULP_inst->cb_index[i][k][ulp], + iLBCenc_inst->ULP_inst->cb_index[i][k][ulp]+ + iLBCenc_inst->ULP_inst->cb_index[i][k][ulp+1]+ + iLBCenc_inst->ULP_inst->cb_index[i][k][ulp+2]); + dopack( &pbytes, firstpart, + iLBCenc_inst->ULP_inst->cb_index[i][k][ulp], + &pos); + } + } + + for (i=0; i<iLBCenc_inst->nasub; i++) { + for (k=0; k<CB_NSTAGES; k++) { + + + packsplit(gain_index+i*CB_NSTAGES+k, &firstpart, + gain_index+i*CB_NSTAGES+k, + iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp], + iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp]+ + iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp+1]+ + iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp+2]); + dopack( &pbytes, firstpart, + iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp], + &pos); + } + } + } + + /* set the last bit to zero (otherwise the decoder + will treat it as a lost frame) */ + dopack( &pbytes, 0, 1, &pos); +} + + + |