diff options
| author | Damian Minkov <damencho@jitsi.org> | 2006-12-16 12:29:44 +0000 |
|---|---|---|
| committer | Damian Minkov <damencho@jitsi.org> | 2006-12-16 12:29:44 +0000 |
| commit | 7c1b3cec1c429ec684489091f33ba035ed37fdf2 (patch) | |
| tree | d3b5250b7fc3527f92a42d8e2bac669ea89b3330 /src | |
| parent | 165fda9dadfd28f466192fb393b99b4074386be1 (diff) | |
| download | jitsi-7c1b3cec1c429ec684489091f33ba035ed37fdf2.zip jitsi-7c1b3cec1c429ec684489091f33ba035ed37fdf2.tar.gz jitsi-7c1b3cec1c429ec684489091f33ba035ed37fdf2.tar.bz2 | |
<No Comment Entered>
Diffstat (limited to 'src')
10 files changed, 6668 insertions, 0 deletions
diff --git a/src/net/java/sip/communicator/impl/media/codec/audio/Utils.java b/src/net/java/sip/communicator/impl/media/codec/audio/Utils.java new file mode 100644 index 0000000..f029bc5 --- /dev/null +++ b/src/net/java/sip/communicator/impl/media/codec/audio/Utils.java @@ -0,0 +1,131 @@ +/* + * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client. + * + * Distributable under LGPL license. + * See terms of license at gnu.org. + */ +package net.java.sip.communicator.impl.media.codec.audio; + +/** + * @author Damian Minkov + */ +public class Utils +{ + /** + * Converts a byte array into a short array. Since a byte is 8-bits, + * and a short is 16-bits, the returned short array will be half in + * length than the byte array. If the length of the byte array is odd, + * the length of the short array will be + * <code>(byteArray.length - 1)/2</code>, i.e., the last byte is + * discarded. + * + * @param byteArray a byte array + * @param offset which byte to start from + * @param length how many bytes to convert + * + * @return a short array, or <code>null</code> if byteArray is of zero + * length + * + * @throws java.lang.ArrayIndexOutOfBoundsException + */ + public static short[] byteToShortArray + (byte[] byteArray, int offset, int length) throws + ArrayIndexOutOfBoundsException + { + + if (0 < length && (offset + length) <= byteArray.length) + { + int shortLength = length / 2; + short[] shortArray = new short[shortLength]; + int temp; + for (int i = offset, j = 0; j < shortLength; + j++, temp = 0x00000000) + { + temp = byteArray[i++] << 8; + temp |= 0x000000FF & byteArray[i++]; + shortArray[j] = (short) temp; + } + return shortArray; + } + else + { + throw new ArrayIndexOutOfBoundsException + ("offset: " + offset + ", length: " + length + + ", array length: " + byteArray.length); + } + } + + /** + * The result array must be twice as the input one. Since a byte is 8-bits, + * and a short is 16-bits. + * @param in short[] + * @param res byte[] + * @param little boolean + * @return byte[] + */ + public static void shortArrToByteArr(short[] in, byte[] res, boolean little) + { + int resIx = 0; + + byte[] tmp = null; + for (int i = 0; i < in.length; i++) + { + tmp = shortToBytes(in[i], little); + res[resIx++] = tmp[0]; + res[resIx++] = tmp[1]; + } + } + + /** + * Get a pair of bytes representing a short value. + * @param v short + * @param little boolean + * @return byte[] + */ + public static byte[] shortToBytes(short v, boolean little) + { + byte[] rtn = new byte[2]; + if (little) + { + rtn[0] = (byte) (v & 0xff); + rtn[1] = (byte) ( (v >>> 8) & 0xff); + } + else + { + rtn[0] = (byte) ( (v >>> 8) & 0xff); + rtn[1] = (byte) (v & 0xff); + } + return rtn; + } + + public static void byteToShortArr(byte[] in, int inOffset, short[] dst) + { + for (int i = 0; i < dst.length; i++) + { + if (in[inOffset + 2 * i + 1] >= 0) + { + dst[i] = in[inOffset + 2 * i + 1]; + dst[i] *= (short) 256; + if ( (in[inOffset + 2 * i + 1] >= 0) && (in[inOffset + 2 * i] < 0)) + dst[i] += (in[inOffset + 2 * i] + 256); + else + dst[i] += (in[inOffset + 2 * i]); + } + else + { + dst[i] = (in[inOffset + 2 * i + 1]); + dst[i]++; + dst[i] *= (short) 256; + if (in[inOffset + 2 * i] < 0) + { + dst[i] += (in[inOffset + 2 * i]); + } + else + { + dst[i] += (in[inOffset + 2 * i]); + dst[i] -= 256; + } + } + } + } +} diff --git a/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/JavaDecoder.java b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/JavaDecoder.java new file mode 100644 index 0000000..c4f4b86 --- /dev/null +++ b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/JavaDecoder.java @@ -0,0 +1,144 @@ +/* + * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client. + * + * Distributable under LGPL license. + * See terms of license at gnu.org. + */ +package net.java.sip.communicator.impl.media.codec.audio.ilbc; + +import javax.media.*; +import javax.media.format.*; + +import net.java.sip.communicator.impl.media.codec.*; +import net.java.sip.communicator.impl.media.codec.audio.*; + +/** iLbc to PCM java decoder + * @author Damian Minkov + **/ +public class JavaDecoder + extends com.ibm.media.codec.audio.AudioCodec +{ + private Format lastFormat = null; + + /** + * The decoder + */ + private ilbc_decoder dec = null; + + public JavaDecoder() + { + inputFormats = new Format[] + { + new AudioFormat( + Constants.ILBC_RTP, + 8000, + 16, + 1, + Format.NOT_SPECIFIED, + Format.NOT_SPECIFIED + )}; + + supportedInputFormats = new AudioFormat[] + { + new AudioFormat(Constants.ILBC_RTP, + 8000, + 16, + 1, + Format.NOT_SPECIFIED, + Format.NOT_SPECIFIED)}; + + defaultOutputFormats = new AudioFormat[] + { + new AudioFormat(AudioFormat.LINEAR)}; + + PLUGIN_NAME = "iLbc Decoder"; + } + + protected Format[] getMatchingOutputFormats(Format in) + { + AudioFormat af = (AudioFormat) in; + + supportedOutputFormats = new AudioFormat[] + { + new AudioFormat( + AudioFormat.LINEAR, + af.getSampleRate(), + 16, + 1, + AudioFormat.LITTLE_ENDIAN, //isBigEndian(), + AudioFormat.SIGNED //isSigned()); + )}; + + return supportedOutputFormats; + + } + + public void open() + {} + + public void close() + {} + + private void initConverter(AudioFormat inFormat, int inputLength) + { + lastFormat = inFormat; + + if(inputLength == ilbc_constants.NO_OF_BYTES_20MS) + dec = new ilbc_decoder(20, 1); + else if(inputLength == ilbc_constants.NO_OF_BYTES_30MS) + dec = new ilbc_decoder(30, 1); + } + + public int process(Buffer inputBuffer, Buffer outputBuffer) + { + if (!checkInputBuffer(inputBuffer)) + { + return BUFFER_PROCESSED_FAILED; + } + + if (isEOM(inputBuffer)) + { + propagateEOM(outputBuffer); + return BUFFER_PROCESSED_OK; + } + + byte[] inData = (byte[]) inputBuffer.getData(); + + int inpLength = inputBuffer.getLength(); + int inOffset = inputBuffer.getOffset(); + + Format newFormat = inputBuffer.getFormat(); + + if (lastFormat != newFormat) + { + initConverter( (AudioFormat) newFormat, inpLength); + } + + + short[] data = Utils.byteToShortArray(inData, inOffset, inpLength); +// +// short[] data = new short[inpLength/2]; +// Utils.byteToShortArr(inData, inOffset, data); + + short[] decodedData = new short[dec.ULP_inst.blockl]; + dec.decode(decodedData, data, (short) 1); + int outLength = dec.ULP_inst.blockl * 2; + byte[] outData = validateByteArraySize(outputBuffer, outLength); + + Utils.shortArrToByteArr(decodedData, outData, true); + + updateOutput(outputBuffer, outputFormat, outLength, 0); + + return BUFFER_PROCESSED_OK; + } + + public java.lang.Object[] getControls() + { + if (controls == null) + { + controls = new Control[1]; + controls[0] = new com.sun.media.controls.SilenceSuppressionAdapter(this, false, false); + } + return (Object[]) controls; + } +} diff --git a/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/JavaEncoder.java b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/JavaEncoder.java new file mode 100644 index 0000000..6d3fd85 --- /dev/null +++ b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/JavaEncoder.java @@ -0,0 +1,156 @@ +/* + * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client. + * + * Distributable under LGPL license. + * See terms of license at gnu.org. + */ +package net.java.sip.communicator.impl.media.codec.audio.ilbc; + +import javax.media.*; +import javax.media.format.*; + +import net.java.sip.communicator.impl.media.codec.*; +import net.java.sip.communicator.impl.media.codec.audio.*; + +/** + * The ilbc Encoder + * + * @author Damian Minkov + */ +public class JavaEncoder + extends com.ibm.media.codec.audio.AudioCodec +{ + private Format lastFormat = null; + + private ilbc_encoder enc = null; + private int ILBC_NO_OF_BYTES = 0; + + public JavaEncoder() + { + supportedInputFormats = new AudioFormat[] + { + new AudioFormat( + AudioFormat.LINEAR, + 8000, + 16, + 1, + AudioFormat.LITTLE_ENDIAN, //isBigEndian(), + AudioFormat.SIGNED //isSigned()); + )}; + + defaultOutputFormats = new AudioFormat[] + {new AudioFormat( + Constants.ILBC_RTP, + 8000.0, + 16, + 1, + AudioFormat.LITTLE_ENDIAN, + AudioFormat.SIGNED)}; + + PLUGIN_NAME = "pcm to iLbc converter"; + } + + protected Format[] getMatchingOutputFormats(Format in) + { + AudioFormat af = (AudioFormat) in; + + supportedOutputFormats = new AudioFormat[] + {new AudioFormat( + Constants.ILBC_RTP, + 8000.0, + 16, + 1, + AudioFormat.LITTLE_ENDIAN, + AudioFormat.SIGNED)}; + + return supportedOutputFormats; + } + + public void open() throws ResourceUnavailableException + { + int mode = Constants.ILBC_MODE; + enc = new ilbc_encoder(mode); + + if(mode == 20) + ILBC_NO_OF_BYTES = ilbc_constants.NO_OF_BYTES_20MS; + else if(mode == 30) + ILBC_NO_OF_BYTES = ilbc_constants.NO_OF_BYTES_30MS; + } + + public void close() + { + + } + + + + private void initConverter(AudioFormat inFormat) + { + lastFormat = inFormat; + } + + public int process(Buffer inputBuffer, Buffer outputBuffer) + { + if (!checkInputBuffer(inputBuffer)) + { + return BUFFER_PROCESSED_FAILED; + } + + if (isEOM(inputBuffer)) + { + propagateEOM(outputBuffer); + return BUFFER_PROCESSED_OK; + } + + + Format newFormat = inputBuffer.getFormat(); + + if (lastFormat != newFormat) + { + initConverter( (AudioFormat) newFormat); + } + + int inpLength = inputBuffer.getLength(); + int inOffset = inputBuffer.getOffset(); + byte[] inpData = (byte[]) inputBuffer.getData(); + + if (inpLength == 0) + { + return OUTPUT_BUFFER_NOT_FILLED; + } + else if(inpLength < enc.ULP_inst.blockl*2) + { + return OUTPUT_BUFFER_NOT_FILLED; + } + + short[] data = new short[enc.ULP_inst.blockl]; + short[] encoded_data = new short[ILBC_NO_OF_BYTES / 2]; + + int outLength = ILBC_NO_OF_BYTES; + byte[] outdata = validateByteArraySize(outputBuffer, outLength); + + Utils.byteToShortArr(inpData, inOffset, data); + + enc.encode(encoded_data, data); + + Utils.shortArrToByteArr(encoded_data, outdata, false); + + updateOutput(outputBuffer, outputFormat, outLength, 0); + + + inputBuffer.setLength(inpLength - enc.ULP_inst.blockl*2); + inputBuffer.setOffset(inOffset + enc.ULP_inst.blockl*2); + + return BUFFER_PROCESSED_OK | INPUT_BUFFER_NOT_CONSUMED; + } + + public java.lang.Object[] getControls() + { + if (controls == null) + { + controls = new Control[1]; + controls[0] = new com.sun.media.controls.SilenceSuppressionAdapter(this, false, false); + } + return (Object[]) controls; + } +} diff --git a/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/bitpack.java b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/bitpack.java new file mode 100644 index 0000000..ad08a5c --- /dev/null +++ b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/bitpack.java @@ -0,0 +1,45 @@ +/* + * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client. + * + * Distributable under LGPL license. + * See terms of license at gnu.org. + */ +package net.java.sip.communicator.impl.media.codec.audio.ilbc; + +import java.lang.*; + +/** + * @author Jean Lorchat + */ +class bitpack { + + int firstpart; + int rest; + + public bitpack() { + firstpart = 0; + rest = 0; + } + + public bitpack(int fp, int r) { + firstpart = fp; + rest = r; + } + + public int get_firstpart() { + return firstpart; + } + + public void set_firstpart(int fp) { + firstpart = fp; + } + + public int get_rest() { + return rest; + } + + public void set_rest(int r) { + rest = r; + } + +} diff --git a/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/bitstream.java b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/bitstream.java new file mode 100644 index 0000000..2458496 --- /dev/null +++ b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/bitstream.java @@ -0,0 +1,183 @@ +/* + * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client. + * + * Distributable under LGPL license. + * See terms of license at gnu.org. + */ +package net.java.sip.communicator.impl.media.codec.audio.ilbc; + +import java.lang.*; + +/** + * @author Jean Lorchat + */ +class bitstream { + + int bitcount; + + int pos; + + char [] buffer; + int buffer_len; + int buffer_pos; + + public bitstream(int size) { + pos = 0; + + buffer_len = size; + buffer_pos = 0; + buffer = new char[size]; + bitcount = 0; + } + + public bitstream() { + pos = 0; + + buffer_len = 128; + buffer_pos = 0; + buffer = new char[128]; + } + + /*----------------------------------------------------------------* + * splitting an integer into first most significant bits and + * remaining least significant bits + *---------------------------------------------------------------*/ + + public bitpack packsplit( + int index, /* (i) the value to split */ + int bitno_firstpart, /* (i) number of bits in most + significant part */ + int bitno_total) /* (i) number of bits in full range + of value */ + { + int bitno_rest = bitno_total - bitno_firstpart; + bitpack rval = new bitpack (); + + int fp = index >>> bitno_rest; + + rval.set_firstpart(fp); + // *firstpart = *index>>(bitno_rest); + rval.set_rest(index - (rval.get_firstpart() << bitno_rest)); + // *rest = *index-(*firstpart<<(bitno_rest)); + return rval; + } + + /*----------------------------------------------------------------* + * combining a value corresponding to msb's with a value + * corresponding to lsb's + *---------------------------------------------------------------*/ + + int packcombine( + int index, /* (i/o) the msb value in the + combined value out */ + int rest, /* (i) the lsb value */ + int bitno_rest /* (i) the number of bits in the + lsb part */ + ){ + index = index << bitno_rest; + index += rest; + return index; + } + + /*----------------------------------------------------------------* + * packing of bits into bitstream, i.e., vector of bytes + *---------------------------------------------------------------*/ + + void dopack( +// unsigned char **bitstream, /* (i/o) on entrance pointer to +// place in bitstream to pack +// new data, on exit pointer +// to place in bitstream to +// pack future data */ + int index, /* (i) the value to pack */ + int bitno /* (i) the number of bits that the + value will fit within */ + ){ + int posLeft; + + // System.out.println("packing " + bitno + " bits (" + index + "), total packed : " + (bitcount+bitno) + " bits to date"); + bitcount += bitno; + + // System.out.println("packing tag " + index + " of length " + bitno + "bits from byte " + buffer_pos + "/" + buffer.length + " at " + pos + "th bit"); + + /* Clear the bits before starting in a new byte */ + + if (pos == 0) { + buffer[buffer_pos] = 0; + } + + while (bitno > 0) { + + /* Jump to the next byte if end of this byte is reached*/ + + if (pos == 8) { + pos = 0; + buffer_pos++; + buffer[buffer_pos] = 0; + } + + posLeft = 8 - pos; + + /* Insert index into the bitstream */ + + if (bitno <= posLeft) { + buffer[buffer_pos] |= (char) (index << (posLeft - bitno)); + pos += bitno; + bitno = 0; + } else { + buffer[buffer_pos] |= (char)(index >>> (bitno - posLeft)); + + pos = 8; + index -= ((index >>> (bitno - posLeft)) << (bitno - posLeft)); + + bitno -= posLeft; + } + } + } + + /*----------------------------------------------------------------* + * unpacking of bits from bitstream, i.e., vector of bytes + *---------------------------------------------------------------*/ + + public int unpack( + int bitno /* (i) number of bits used to + represent the value */ + ) + { + int BitsLeft; + int index=0; + + while (bitno > 0) { + + /* move forward in bitstream when the end of the + byte is reached */ + + if (pos == 8) { + pos = 0; + buffer_pos++; + } + + BitsLeft = 8 - pos; + + /* Extract bits to index */ + + if (BitsLeft >= bitno) { + index += ((((buffer[buffer_pos]) << (pos)) & 0xFF) >>> (8 - bitno)); + pos += bitno; + bitno = 0; + } else { + + if ((8 - bitno) > 0) { + index+=((((buffer[buffer_pos]) << (pos)) & 0xFF) >>> (8 - bitno)); + pos=8; + } else { + index+=(((int)(((buffer[buffer_pos]) << (pos)) & 0xFF)) << (bitno - 8)); + pos=8; + } + bitno -= BitsLeft; + } + } + + return index; + } +} diff --git a/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/ilbc_common.java b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/ilbc_common.java new file mode 100644 index 0000000..5a13416 --- /dev/null +++ b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/ilbc_common.java @@ -0,0 +1,726 @@ +/* + * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client. + * + * Distributable under LGPL license. + * See terms of license at gnu.org. + */ +package net.java.sip.communicator.impl.media.codec.audio.ilbc; + +import java.lang.*; + +/** + * @author Jean Lorchat + */ +class ilbc_common { + + /*----------------------------------------------------------------* + * check for stability of lsf coefficients + *---------------------------------------------------------------*/ + + public static int LSF_check( /* (o) 1 for stable lsf vectors and 0 for + nonstable ones */ + float lsf[], /* (i) a table of lsf vectors */ + int dim, /* (i) the dimension of each lsf vector */ + int NoAn) /* (i) the number of lsf vectors in the + table */ + { + int k,n,m, Nit=2, change=0,pos; + float tmp; + float eps=(float)0.039; /* 50 Hz */ + float eps2=(float)0.0195; + float maxlsf=(float)3.14; /* 4000 Hz */ + float minlsf=(float)0.01; /* 0 Hz */ + + /* LSF separation check*/ + + for (n=0; n<Nit; n++) { /* Run through a couple of times */ + for (m=0; m<NoAn; m++) { /* Number of analyses per frame */ + for (k=0; k<(dim-1); k++) { + pos=m*dim+k; + + if ((lsf[pos+1]-lsf[pos])<eps) { + + if (lsf[pos+1]<lsf[pos]) { + tmp=lsf[pos+1]; + lsf[pos+1]= lsf[pos]+eps2; + lsf[pos]= lsf[pos+1]-eps2; + } else { + lsf[pos]-=eps2; + lsf[pos+1]+=eps2; + } + change=1; + } + + if (lsf[pos]<minlsf) { + lsf[pos]=minlsf; + change=1; + } + + if (lsf[pos]>maxlsf) { + lsf[pos]=maxlsf; + change=1; + } + } + } + } + + return change; + } + + /*----------------------------------------------------------------* + * decoding of the start state + *---------------------------------------------------------------*/ + + public static void StateConstructW( + int idxForMax, /* (i) 6-bit index for the quantization of + max amplitude */ + int idxVec[], /* (i) vector of quantization indexes */ + float syntDenum[], /* (i) synthesis filter denumerator */ + int syntDenum_idx, + float out[], /* (o) the decoded state vector */ + int out_idx, + int len /* (i) length of a state vector */ + ){ + float maxVal; + float [] tmpbuf = new float[ilbc_constants.LPC_FILTERORDER+2*ilbc_constants.STATE_LEN]; + //, *tmp, + int tmp; + float [] numerator = new float[ilbc_constants.LPC_FILTERORDER+1]; + float [] foutbuf = new float[ilbc_constants.LPC_FILTERORDER+2*ilbc_constants.STATE_LEN]; + //, *fout; + int fout; + int k,tmpi; + + /* decoding of the maximum value */ + + maxVal = ilbc_constants.state_frgqTbl[idxForMax]; + //System.out.println("idxForMax : " + idxForMax + "maxVal : " + maxVal); + maxVal = (float)Math.pow(10,maxVal) / 4.5f; + //System.out.println("maxVal : " + maxVal); + + /* initialization of buffers and coefficients */ + + for (int li = 0; li < ilbc_constants.LPC_FILTERORDER; li++) { + tmpbuf[li] = 0.0f; + foutbuf[li] = 0.0f; + } + // memset(tmpbuf, 0, LPC_FILTERORDER*sizeof(float)); + // memset(foutbuf, 0, LPC_FILTERORDER*sizeof(float)); + + for (k=0; k < ilbc_constants.LPC_FILTERORDER; k++) { + numerator[k]=syntDenum[syntDenum_idx + ilbc_constants.LPC_FILTERORDER - k]; + //System.out.println("numerator-" + k + " = " + numerator[k] + " (( " + syntDenum[syntDenum_idx + ilbc_constants.LPC_FILTERORDER - k]); + } + + numerator[ilbc_constants.LPC_FILTERORDER]=syntDenum[syntDenum_idx]; + // tmp = &tmpbuf[LPC_FILTERORDER]; + tmp = ilbc_constants.LPC_FILTERORDER; + // fout = &foutbuf[LPC_FILTERORDER]; + fout = ilbc_constants.LPC_FILTERORDER; + + /* decoding of the sample values */ + + // for (int li = 0; li < idxVec.length; li++) + //System.out.println("idxVec["+li+"] = " + idxVec[li]); + + for (k=0; k<len; k++) { + tmpi = len-1-k; + /* maxVal = 1/scal */ + tmpbuf[tmp+k] = maxVal*ilbc_constants.state_sq3Tbl[idxVec[tmpi]]; + //System.out.println("index " + k + ", valeur " + tmpbuf[tmp+k]); + } + + /* circular convolution with all-pass filter */ + + for (int li = 0; li < len; li++) + tmpbuf[tmp+len+li] = 0.0f; + // memset(tmp+len, 0, len*sizeof(float)); + ilbc_common.ZeroPoleFilter(tmpbuf, tmp, numerator, syntDenum, syntDenum_idx, + 2*len, ilbc_constants.LPC_FILTERORDER, + foutbuf, fout); + for (k=0;k<len;k++) { + out[out_idx+k] = foutbuf[fout+len-1-k]+foutbuf[fout+2*len-1-k]; + //System.out.println("MEM -- index " + out_idx + " + " + k + " initialise a " + out[out_idx+k]); + //System.out.println(" calcul : " + foutbuf[fout+len-1-k] + " + " + foutbuf[fout+2*len-1-k]); + } + } + + + /*----------------------------------------------------------------* + * all-pole filter + *---------------------------------------------------------------*/ + + public static void AllPoleFilter( + float InOut[], /* (i/o) on entrance InOut[-orderCoef] to + InOut[-1] contain the state of the + filter (delayed samples). InOut[0] to + InOut[lengthInOut-1] contain the filter + input, on en exit InOut[-orderCoef] to + InOut[-1] is unchanged and InOut[0] to + InOut[lengthInOut-1] contain filtered + samples */ + int InOut_idx, + float Coef[],/* (i) filter coefficients, Coef[0] is assumed + to be 1.0f */ + int Coef_idx, + int lengthInOut,/* (i) number of input/output samples */ + int orderCoef) /* (i) number of filter coefficients */ + { + int n, k; + + for(n = 0; n < lengthInOut; n++) { + for(k = 1; k <= orderCoef; k++) { + InOut[n+InOut_idx] -= Coef[Coef_idx + k] * InOut[n-k+InOut_idx]; + } + } + } + + /*----------------------------------------------------------------* + * all-zero filter + *---------------------------------------------------------------*/ + + public static void AllZeroFilter( + float In[], /* (i) In[0] to In[lengthInOut-1] contain + filter input samples */ + int In_idx, + float Coef[],/* (i) filter coefficients (Coef[0] is assumed + to be 1.0f) */ + int lengthInOut,/* (i) number of input/output samples */ + int orderCoef, /* (i) number of filter coefficients */ + float Out[], /* (i/o) on entrance Out[-orderCoef] to Out[-1] + contain the filter state, on exit Out[0] + to Out[lengthInOut-1] contain filtered + samples */ + int Out_idx) + { + int n, k; + + for(n = 0; n < lengthInOut; n++) { + Out[Out_idx] = Coef[0]*In[In_idx]; + for(k=1;k<=orderCoef;k++){ + Out[Out_idx] += Coef[k]*In[In_idx-k]; + } + Out_idx++; + In_idx++; + } + } + + /*----------------------------------------------------------------* + * pole-zero filter + *---------------------------------------------------------------*/ + + public static void ZeroPoleFilter( + float In[], /* (i) In[0] to In[lengthInOut-1] contain + filter input samples In[-orderCoef] to + In[-1] contain state of all-zero + section */ + int In_idx, + float ZeroCoef[],/* (i) filter coefficients for all-zero + section (ZeroCoef[0] is assumed to + be 1.0f) */ + float PoleCoef[],/* (i) filter coefficients for all-pole section + (ZeroCoef[0] is assumed to be 1.0f) */ + int PoleCoef_idx, + int lengthInOut,/* (i) number of input/output samples */ + int orderCoef, /* (i) number of filter coefficients */ + float Out[], /* (i/o) on entrance Out[-orderCoef] to Out[-1] + contain state of all-pole section. On + exit Out[0] to Out[lengthInOut-1] + contain filtered samples */ + int Out_idx) + { + AllZeroFilter(In, In_idx, ZeroCoef, lengthInOut, orderCoef, Out, Out_idx); + AllPoleFilter(Out, Out_idx, PoleCoef, PoleCoef_idx, lengthInOut, orderCoef); + } + + /*----------------------------------------------------------------* + * conversion from lsf coefficients to lpc coefficients + *---------------------------------------------------------------*/ + + public static void lsf2a(float a_coef[], float freq[]) + { + int i, j; + float hlp; + float [] p = new float[ilbc_constants.LPC_HALFORDER]; + float [] q = new float[ilbc_constants.LPC_HALFORDER]; + float [] a = new float[ilbc_constants.LPC_HALFORDER + 1]; + float [] a1 = new float[ilbc_constants.LPC_HALFORDER]; + float [] a2 = new float[ilbc_constants.LPC_HALFORDER]; + float [] b = new float[ilbc_constants.LPC_HALFORDER + 1]; + float [] b1 = new float[ilbc_constants.LPC_HALFORDER]; + float [] b2 = new float[ilbc_constants.LPC_HALFORDER]; + + //System.out.println("debut de lsf2a"); + + for (i=0; i < ilbc_constants.LPC_FILTERORDER; i++) { + freq[i] = freq[i] * ilbc_constants.PI2; + } + + /* Check input for ill-conditioned cases. This part is not + found in the TIA standard. It involves the following 2 IF + blocks. If "freq" is judged ill-conditioned, then we first + modify freq[0] and freq[LPC_HALFORDER-1] (normally + LPC_HALFORDER = 10 for LPC applications), then we adjust + the other "freq" values slightly */ + + if ((freq[0] <= 0.0f) || (freq[ilbc_constants.LPC_FILTERORDER - 1] >= 0.5)){ + + + if (freq[0] <= 0.0f) { + freq[0] = (float)0.022; + } + + + if (freq[ilbc_constants.LPC_FILTERORDER - 1] >= 0.5) { + freq[ilbc_constants.LPC_FILTERORDER - 1] = (float)0.499; + } + + hlp = (freq[ilbc_constants.LPC_FILTERORDER - 1] - freq[0]) / + (float) (ilbc_constants.LPC_FILTERORDER - 1); + + for (i=1; i < ilbc_constants.LPC_FILTERORDER; i++) { + freq[i] = freq[i - 1] + hlp; + } + } + + for (int li = 0; li < ilbc_constants.LPC_HALFORDER; li++) { + a1[li] = 0.0f; + a2[li] = 0.0f; + b1[li] = 0.0f; + b2[li] = 0.0f; + } +// memset(a1, 0, LPC_HALFORDER*sizeof(float)); +// memset(a2, 0, LPC_HALFORDER*sizeof(float)); +// memset(b1, 0, LPC_HALFORDER*sizeof(float)); +// memset(b2, 0, LPC_HALFORDER*sizeof(float)); + for (int li = 0; li < ilbc_constants.LPC_HALFORDER + 1; li++) { + a[li] = 0.0f; + b[li] = 0.0f; + } +// memset(a, 0, (LPC_HALFORDER+1)*sizeof(float)); +// memset(b, 0, (LPC_HALFORDER+1)*sizeof(float)); + + /* p[i] and q[i] compute cos(2*pi*omega_{2j}) and + cos(2*pi*omega_{2j-1} in eqs. 4.2.2.2-1 and 4.2.2.2-2. + Note that for this code p[i] specifies the coefficients + used in .Q_A(z) while q[i] specifies the coefficients used + in .P_A(z) */ + + for (i = 0; i < ilbc_constants.LPC_HALFORDER; i++) { + p[i] = (float)Math.cos(ilbc_constants.TWO_PI * freq[2 * i]); + q[i] = (float)Math.cos(ilbc_constants.TWO_PI * freq[2 * i + 1]); + } + + a[0] = 0.25f; + b[0] = 0.25f; + + for (i= 0; i < ilbc_constants.LPC_HALFORDER; i++) { + a[i + 1] = a[i] - 2 * p[i] * a1[i] + a2[i]; + b[i + 1] = b[i] - 2 * q[i] * b1[i] + b2[i]; + a2[i] = a1[i]; + a1[i] = a[i]; + b2[i] = b1[i]; + b1[i] = b[i]; + } + + for (j=0; j < ilbc_constants.LPC_FILTERORDER; j++) { + + if (j == 0) { + a[0] = 0.25f; + b[0] = -0.25f; + } else { + a[0] = b[0] = 0.0f; + } + + for (i=0; i < ilbc_constants.LPC_HALFORDER; i++) { + a[i + 1] = a[i] - 2 * p[i] * a1[i] + a2[i]; + b[i + 1] = b[i] - 2 * q[i] * b1[i] + b2[i]; + a2[i] = a1[i]; + a1[i] = a[i]; + b2[i] = b1[i]; + b1[i] = b[i]; + } + + a_coef[j + 1] = 2 * (a[ilbc_constants.LPC_HALFORDER] + + b[ilbc_constants.LPC_HALFORDER]); + } + + a_coef[0] = 1.0f; + } + + /*----------------------------------------------------------------* + * Construct decoded vector from codebook and gains. + *---------------------------------------------------------------*/ + + /*----------------------------------------------------------------* + * interpolation between vectors + *---------------------------------------------------------------*/ + + public static void interpolate( + float out[], /* (o) the interpolated vector */ + float in1[], /* (i) the first vector for the + interpolation */ + float in2[], /* (i) the second vector for the + interpolation */ + int in2_idx, + float coef, /* (i) interpolation weights */ + int length) /* (i) length of all vectors */ + { + int i; + float invcoef; + + invcoef = (float)1.0f - coef; + for (i = 0; i < length; i++) { + out[i] = coef * in1[i] + invcoef * in2[i + in2_idx]; + // System.out.println("out["+i+"] devient " + out[i] + ", par " + + // coef + " * " + in1[i] + " + " + invcoef + " * " + in2[i + in2_idx]); + } + } + + /*----------------------------------------------------------------* + * lpc bandwidth expansion + *---------------------------------------------------------------*/ + + public static void bwexpand( + float out[], /* (o) the bandwidth expanded lpc + coefficients */ + int out_idx, + float in[], /* (i) the lpc coefficients before bandwidth + expansion */ + float coef, /* (i) the bandwidth expansion factor */ + int length) /* (i) the length of lpc coefficient vectors */ + { + int i; + float chirp; + + chirp = coef; + + out[out_idx] = in[0]; + for (i = 1; i < length; i++) { + out[i + out_idx] = chirp * in[i]; + chirp *= coef; + } + } + + public static void getCBvec( + float cbvec[], /* (o) Constructed codebook vector */ + float mem[], /* (i) Codebook buffer */ + int mem_idx, + int index, /* (i) Codebook index */ + int lMem, /* (i) Length of codebook buffer */ + int cbveclen) /* (i) Codebook vector length */ + { + int j, k, n, memInd, sFilt; + float [] tmpbuf = new float[ilbc_constants.CB_MEML]; + int base_size; + int ilow, ihigh; + float alfa, alfa1; + + /* Determine size of codebook sections */ + + base_size=lMem-cbveclen+1; + + if (cbveclen==ilbc_constants.SUBL) { + base_size+=cbveclen/2; + } + + /* No filter -> First codebook section */ + + if (index<lMem-cbveclen+1) { + + /* first non-interpolated vectors */ + + k=index+cbveclen; + /* get vector */ + System.arraycopy(mem, mem_idx + lMem - k, cbvec, 0, cbveclen); + // memcpy(cbvec, mem+lMem-k, cbveclen*sizeof(float)); + + } else if (index < base_size) { + + k=2*(index-(lMem-cbveclen+1))+cbveclen; + + ihigh=k/2; + ilow=ihigh-5; + + /* Copy first noninterpolated part */ + + System.arraycopy(mem, mem_idx + lMem - k / 2, cbvec, 0, ilow); + // memcpy(cbvec, mem+lMem-k/2, ilow*sizeof(float)); + + /* interpolation */ + + alfa1=(float)0.2; + alfa=0.0f; + for (j=ilow; j<ihigh; j++) { + cbvec[j]=((float)1.0f-alfa)*mem[mem_idx + lMem-k/2+j]+ + alfa*mem[mem_idx + lMem-k+j]; + alfa+=alfa1; + } + + /* Copy second noninterpolated part */ + + System.arraycopy(mem, mem_idx+lMem-k+ihigh, cbvec, ihigh, (cbveclen-ihigh)); +// memcpy(cbvec+ihigh, mem+lMem-k+ihigh, +// (cbveclen-ihigh)*sizeof(float)); + + } + + /* Higher codebook section based on filtering */ + + else { + + /* first non-interpolated vectors */ + + if (index-base_size<lMem-cbveclen+1) { + float [] tempbuff2 = new float[ilbc_constants.CB_MEML+ilbc_constants.CB_FILTERLEN+1]; +// float *pos; +// float *pp, *pp1; + int pos, pp, pp1; + + for (int li = 0; li < ilbc_constants.CB_HALFFILTERLEN; li++) + tempbuff2[li] = 0.0f; +// memset(tempbuff2, 0, +// CB_HALFFILTERLEN*sizeof(float)); + System.arraycopy(mem, mem_idx, tempbuff2, ilbc_constants.CB_HALFFILTERLEN, lMem); +// memcpy(&tempbuff2[CB_HALFFILTERLEN], mem, +// lMem*sizeof(float)); + for (int li = 0; li < ilbc_constants.CB_HALFFILTERLEN + 1; li++) + tempbuff2[lMem + ilbc_constants.CB_HALFFILTERLEN + li] = 0.0f; +// memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0, +// (CB_HALFFILTERLEN+1)*sizeof(float)); + + k=index-base_size+cbveclen; + sFilt=lMem-k; + memInd=sFilt+1-ilbc_constants.CB_HALFFILTERLEN; + + /* do filtering */ + // pos=cbvec; + pos = 0; + for (int li = 0; li < cbveclen; li++) + cbvec[li] = 0; +// memset(pos, 0, cbveclen*sizeof(float)); + for (n=0; n<cbveclen; n++) { + pp = memInd + n + ilbc_constants.CB_HALFFILTERLEN; +// pp=&tempbuff2[memInd+n+CB_HALFFILTERLEN]; + pp1 = ilbc_constants.CB_FILTERLEN - 1; +// pp1=&cbfiltersTbl[CB_FILTERLEN-1]; + for (j=0; j < ilbc_constants.CB_FILTERLEN; j++) { +// (*pos)+=(*pp++)*(*pp1--); + cbvec[pos] += tempbuff2[pp] * ilbc_constants.cbfiltersTbl[pp1]; + pp++; + pp1--; + } + pos++; + } + } + + /* interpolated vectors */ + + else { + float [] tempbuff2 = new float[ilbc_constants.CB_MEML+ilbc_constants.CB_FILTERLEN+1]; + +// float *pos; +// float *pp, *pp1; + int pos, pp, pp1; + int i; + + for (int li = 0; li < ilbc_constants.CB_HALFFILTERLEN; li++) + tempbuff2[li] = 0.0f; +// memset(tempbuff2, 0, +// CB_HALFFILTERLEN*sizeof(float)); + System.arraycopy(mem, mem_idx, tempbuff2, ilbc_constants.CB_HALFFILTERLEN, lMem); +// memcpy(&tempbuff2[CB_HALFFILTERLEN], mem, +// lMem*sizeof(float)); + for (int li = 0; li < ilbc_constants.CB_HALFFILTERLEN; li++) + tempbuff2[lMem+ilbc_constants.CB_HALFFILTERLEN+li] = 0.0f; +// memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0, +// (CB_HALFFILTERLEN+1)*sizeof(float)); + + k=2*(index-base_size- + (lMem-cbveclen+1))+cbveclen; + sFilt=lMem-k; + memInd=sFilt+1 - ilbc_constants.CB_HALFFILTERLEN; + + /* do filtering */ + // pos=&tmpbuf[sFilt]; + pos = sFilt; + // memset(pos, 0, k*sizeof(float)); + for (int li = 0; li < k; li++) + tmpbuf[pos+li] = 0.0f; + + for (i=0; i<k; i++) { + pp = memInd + i + ilbc_constants.CB_HALFFILTERLEN; +// pp=&tempbuff2[memInd+i+CB_HALFFILTERLEN]; + pp1 = ilbc_constants.CB_FILTERLEN-1; +// pp1=&cbfiltersTbl[CB_FILTERLEN-1]; + for (j=0; j < ilbc_constants.CB_FILTERLEN; j++) { + // (*pos)+=(*pp++)*(*pp1--); + tmpbuf[pos] += tempbuff2[pp] * ilbc_constants.cbfiltersTbl[pp1]; + pp++; + pp1--; + } + pos++; + } + + ihigh = k / 2; + ilow=ihigh-5; + + /* Copy first noninterpolated part */ + + System.arraycopy(tmpbuf, lMem - k / 2, cbvec, 0, ilow); +// memcpy(cbvec, tmpbuf+lMem-k/2, +// ilow*sizeof(float)); + + /* interpolation */ + + alfa1=(float)0.2; + alfa=0.0f; + for (j=ilow; j<ihigh; j++) { + cbvec[j]=((float)1.0f-alfa)* + tmpbuf[lMem-k/2+j]+alfa*tmpbuf[lMem-k+j]; + alfa+=alfa1; + } + + /* Copy second noninterpolated part */ + + System.arraycopy(tmpbuf, lMem-k+ihigh, cbvec, ihigh, cbveclen - ihigh); +// memcpy(cbvec+ihigh, tmpbuf+lMem-k+ihigh, +// (cbveclen-ihigh)*sizeof(float)); + } + } + } + + + + public static float gainquant(/* (o) quantized gain value */ + float in, /* (i) gain value */ + float maxIn,/* (i) maximum of gain value */ + int cblen, /* (i) number of quantization indices */ + int index[], /* (o) quantization index */ + int index_idx) + { + int i, tindex; + float minmeasure,measure, cb[], scale; + + /* ensure a lower bound on the scaling factor */ + + scale = maxIn; + + if (scale < 0.1) { + scale = (float)0.1; + } + + /* select the quantization table */ + + if (cblen == 8) { + cb = ilbc_constants.gain_sq3Tbl; + } else if (cblen == 16) { + cb = ilbc_constants.gain_sq4Tbl; + } else { + cb = ilbc_constants.gain_sq5Tbl; + } + + /* select the best index in the quantization table */ + + minmeasure=10000000.0f; + tindex=0; + for (i=0; i<cblen; i++) { + measure = (in - scale*cb[i])*(in-scale*cb[i]); + + if (measure<minmeasure) { + tindex=i; + minmeasure=measure; + } + } + index[index_idx] = tindex; + + /* return the quantized value */ + + return scale*cb[tindex]; + } + + /*----------------------------------------------------------------* + * decoder for quantized gains in the gain-shape coding of + * residual + *---------------------------------------------------------------*/ + + public static float gaindequant( /* (o) quantized gain value */ + int index, /* (i) quantization index */ + float maxIn,/* (i) maximum of unquantized gain */ + int cblen) /* (i) number of quantization indices */ + { + float scale; + + /* obtain correct scale factor */ + + scale=(float)(float)Math.abs(maxIn); + + if (scale < 0.1) { + scale=(float)0.1; + } + + /* select the quantization table and return the decoded value */ + + if (cblen==8) { + return scale*ilbc_constants.gain_sq3Tbl[index]; + } else if (cblen==16) { + return scale*ilbc_constants.gain_sq4Tbl[index]; + } + else if (cblen==32) { + return scale*ilbc_constants.gain_sq5Tbl[index]; + } + + return 0.0f; + } + + + public static void iCBConstruct( + float decvector[], /* (o) Decoded vector */ + int decvector_idx, + int index[], /* (i) Codebook indices */ + int index_idx, + int gain_index[],/* (i) Gain quantization indices */ + int gain_index_idx, + float mem[], /* (i) Buffer for codevector construction */ + int mem_idx, + int lMem, /* (i) Length of buffer */ + int veclen, /* (i) Length of vector */ + int nStages /* (i) Number of codebook stages */ + ){ + int j,k; + + float [] gain = new float[ilbc_constants.CB_NSTAGES]; + float [] cbvec = new float[ilbc_constants.SUBL]; + + /* gain de-quantization */ + + gain[0] = gaindequant(gain_index[gain_index_idx + 0], 1.0f, 32); + if (nStages > 1) { + gain[1] = gaindequant(gain_index[gain_index_idx + 1], + (float)(float)Math.abs(gain[0]), 16); + } + if (nStages > 2) { + gain[2] = gaindequant(gain_index[gain_index_idx + 2], + (float)(float)Math.abs(gain[1]), 8); + } + + /* codebook vector construction and construction of + total vector */ + + getCBvec(cbvec, mem, mem_idx, index[index_idx + 0], lMem, veclen); + for (j=0;j<veclen;j++){ + decvector[decvector_idx + j] = gain[0]*cbvec[j]; + } + if (nStages > 1) { + for (k=1; k<nStages; k++) { + getCBvec(cbvec, mem, mem_idx, index[index_idx + k], lMem, veclen); + for (j=0;j<veclen;j++) { + decvector[decvector_idx + j] += gain[k]*cbvec[j]; + } + } + } + } + + + +} diff --git a/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/ilbc_constants.java b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/ilbc_constants.java new file mode 100644 index 0000000..81f2474 --- /dev/null +++ b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/ilbc_constants.java @@ -0,0 +1,778 @@ +/* + * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client. + * + * Distributable under LGPL license. + * See terms of license at gnu.org. + */ +package net.java.sip.communicator.impl.media.codec.audio.ilbc; + +/** + * @author Jean Lorchat + */ +class ilbc_constants { + /* general codec settings */ + + static float FS = (float)8000.0f; + static int BLOCKL_20MS = 160; + static int BLOCKL_30MS = 240; + static int BLOCKL_MAX = 240; + static int NSUB_20MS = 4; + static int NSUB_30MS = 6; + static int NSUB_MAX = 6; + static int NASUB_20MS = 2; + static int NASUB_30MS = 4; + static int NASUB_MAX = 4; + static int SUBL = 40; + static int STATE_LEN = 80; + static int STATE_SHORT_LEN_30MS = 58; + static int STATE_SHORT_LEN_20MS = 57; + + /* LPC settings */ + + static int LPC_FILTERORDER = 10; + static float LPC_CHIRP_SYNTDENUM = (float)0.9025; + static float LPC_CHIRP_WEIGHTDENUM = (float)0.4222; + static int LPC_LOOKBACK = 60; + static int LPC_N_20MS = 1; + static int LPC_N_30MS = 2; + static int LPC_N_MAX = 2; + static int LPC_ASYMDIFF = 20; + static float LPC_BW = (float)60.0f; + static float LPC_WN = (float)1.0001f; + static int LSF_NSPLIT = 3; + static int LSF_NUMBER_OF_STEPS = 4; + static int LPC_HALFORDER = (LPC_FILTERORDER/2); + + /* cb settings */ + + static int CB_NSTAGES = 3; + static int CB_EXPAND = 2; + static int CB_MEML = 147; + static int CB_HALFFILTERLEN = 4; + static int CB_FILTERLEN = 2*CB_HALFFILTERLEN; + static int CB_RESRANGE = 34; + static float CB_MAXGAIN = (float)1.3; + + /* enhancer */ + + static int ENH_BLOCKL = 80; /* block length */ + static int ENH_BLOCKL_HALF = (ENH_BLOCKL/2); + static int ENH_HL = 3; /* 2*ENH_HL+1 is number blocks + in said second sequence */ + static int ENH_SLOP = 2; /* max difference estimated and + correct pitch period */ + static int ENH_PLOCSL = 20; /* pitch-estimates and pitch- + locations buffer length */ + static int ENH_OVERHANG = 2; + static int ENH_UPS0 = 4; /* upsampling rate */ + static int ENH_FL0 = 3; /* 2*FLO+1 is the length of + each filter */ + static int ENH_VECTL = (ENH_BLOCKL+2*ENH_FL0); + static int ENH_CORRDIM = (2*ENH_SLOP+1); + static int ENH_NBLOCKS = (BLOCKL_MAX/ENH_BLOCKL); + static int ENH_NBLOCKS_EXTRA = 5; + static int ENH_NBLOCKS_TOT = 8; /* ENH_NBLOCKS + + ENH_NBLOCKS_EXTRA */ + static int ENH_BUFL = (ENH_NBLOCKS_TOT)*ENH_BLOCKL; + static float ENH_ALPHA0 = (float)0.05f; + + /* Down sampling */ + + static int FILTERORDER_DS = 7; + static int DELAY_DS = 3; + static int FACTOR_DS = 2; + + /* bit stream defs */ + + static int NO_OF_BYTES_20MS = 38; + static int NO_OF_BYTES_30MS = 50; + static int NO_OF_WORDS_20MS = 19; + static int NO_OF_WORDS_30MS = 25; + static int STATE_BITS = 3; + static int BYTE_LEN = 8; + static int ULP_CLASSES = 3; + + /* help parameters */ + + static float DOUBLE_MAX = (float)1.0e37; + static float EPS = (float)2.220446049250313e-016; + static float PI = (float)3.14159265358979323846; + static int MIN_SAMPLE = -32768; + static int MAX_SAMPLE = 32767; + static float TWO_PI = (float)6.283185307; + static float PI2 = (float)0.159154943; + + /* */ + + static int lsf_bits_20ms[][] = { {6,0,0,0,0}, {7,0,0,0,0}, {7,0,0,0,0}, + {0,0,0,0,0}, {0,0,0,0,0}, {0,0,0,0,0}}; + static int start_bits_20ms[] = {2,0,0,0,0}; + static int startfirst_bits_20ms[] = {1,0,0,0,0}; + static int scale_bits_20ms[] = {6,0,0,0,0}; + static int state_bits_20ms[] = {0,1,2,0,0}; + + static int extra_cb_index_20ms[][] = {{6,0,1,0,0}, {0,0,7,0,0}, {0,0,7,0,0}}; + static int extra_cb_gain_20ms[][] = {{2,0,3,0,0}, {1,1,2,0,0}, {0,0,3,0,0}}; + + static int cb_index_20ms[][][] = { {{7,0,1,0,0}, {0,0,7,0,0}, {0,0,7,0,0}}, + {{0,0,8,0,0}, {0,0,8,0,0}, {0,0,8,0,0}}, + {{0,0,0,0,0}, {0,0,0,0,0}, {0,0,0,0,0}}, + {{0,0,0,0,0}, {0,0,0,0,0}, {0,0,0,0,0}}}; + + static int cb_gain_20ms[][][] = { {{1,2,2,0,0}, {1,1,2,0,0}, {0,0,3,0,0}}, + {{1,1,3,0,0}, {0,2,2,0,0}, {0,0,3,0,0}}, + {{0,0,0,0,0}, {0,0,0,0,0}, {0,0,0,0,0}}, + {{0,0,0,0,0}, {0,0,0,0,0}, {0,0,0,0,0}}}; + + + static int lsf_bits_30ms[][] = { {6,0,0,0,0}, {7,0,0,0,0}, {7,0,0,0,0}, + {6,0,0,0,0}, {7,0,0,0,0}, {7,0,0,0,0}}; + static int start_bits_30ms[] = {3,0,0,0,0}; + static int startfirst_bits_30ms[] = {1,0,0,0,0}; + static int scale_bits_30ms[] = {6,0,0,0,0}; + static int state_bits_30ms[] = {0,1,2,0,0}; + + static int extra_cb_index_30ms[][] = {{4,2,1,0,0}, {0,0,7,0,0}, {0,0,7,0,0}}; + static int extra_cb_gain_30ms[][] = {{1,1,3,0,0}, {1,1,2,0,0}, {0,0,3,0,0}}; + + static int cb_index_30ms[][][] = { {{6,1,1,0,0}, {0,0,7,0,0}, {0,0,7,0,0}}, + {{0,7,1,0,0}, {0,0,8,0,0}, {0,0,8,0,0}}, + {{0,7,1,0,0}, {0,0,8,0,0}, {0,0,8,0,0}}, + {{0,7,1,0,0}, {0,0,8,0,0}, {0,0,8,0,0}}, + {{0,0,0,0,0}, {0,0,0,0,0}, {0,0,0,0,0}}, + {{0,0,0,0,0}, {0,0,0,0,0}, {0,0,0,0,0}}}; + + static int cb_gain_30ms[][][] = { {{1,2,2,0,0}, {1,2,1,0,0}, {0,0,3,0,0}}, + {{0,2,3,0,0}, {0,2,2,0,0}, {0,0,3,0,0}}, + {{0,1,4,0,0}, {0,1,3,0,0}, {0,0,3,0,0}}, + {{0,1,4,0,0}, {0,1,3,0,0}, {0,0,3,0,0}}, + {{0,0,0,0,0}, {0,0,0,0,0}, {0,0,0,0,0}}, + {{0,0,0,0,0}, {0,0,0,0,0}, {0,0,0,0,0}}}; + + /* HP filters */ + static float hpi_zero_coefsTbl[] = {(float)0.92727436f, (float)-1.8544941f, (float)0.92727436f}; + static float hpi_pole_coefsTbl[] = {(float)1.0f, (float)-1.9059465f, (float)0.9114024f}; + static float hpo_zero_coefsTbl[] = {(float)0.93980581f, (float)-1.8795834f, (float)0.93980581f}; + static float hpo_pole_coefsTbl[] = {(float)1.0f, (float)-1.9330735f, (float)0.93589199f}; + + /* LP Filter */ + + static float lpFilt_coefsTbl[] = {(float)-0.066650, (float)0.125000, + (float)0.316650, (float)0.414063, + (float)0.316650, (float)0.125000, + (float)-0.066650}; + + /* State quantization tables */ + + static float state_sq3Tbl[] = { + (float)-3.719849, (float)-2.177490, (float)-1.130005, + (float)-0.309692, (float)0.444214, (float)1.329712, + (float)2.436279, (float)3.983887 + }; + + static float state_frgqTbl[] = { + (float)1.000085, (float)1.071695, (float)1.140395, + (float)1.206868, (float)1.277188, (float)1.351503, + (float)1.429380, (float)1.500727, (float)1.569049, + (float)1.639599, (float)1.707071, (float)1.781531, + (float)1.840799, (float)1.901550, (float)1.956695, + (float)2.006750, (float)2.055474, (float)2.102787, + (float)2.142819, (float)2.183592, (float)2.217962, + (float)2.257177, (float)2.295739, (float)2.332967, + (float)2.369248, (float)2.402792, (float)2.435080, + (float)2.468598, (float)2.503394, (float)2.539284, + (float)2.572944, (float)2.605036, (float)2.636331, + (float)2.668939, (float)2.698780, (float)2.729101, + (float)2.759786, (float)2.789834, (float)2.818679, + (float)2.848074, (float)2.877470, (float)2.906899, + (float)2.936655, (float)2.967804, (float)3.000115, + (float)3.033367, (float)3.066355, (float)3.104231, + (float)3.141499, (float)3.183012, (float)3.222952, + (float)3.265433, (float)3.308441, (float)3.350823, + (float)3.395275, (float)3.442793, (float)3.490801, + (float)3.542514, (float)3.604064, (float)3.666050, + (float)3.740994, (float)3.830749, (float)3.938770, + (float)4.101764 + }; + + /* CB tables */ + + static int search_rangeTbl[][]={{58,58,58}, {108,44,44}, + {108,108,108}, {108,108,108}, {108,108,108}}; + static int stMemLTbl=85; + static int memLfTbl[]={147,147,147,147}; + + /* expansion filter(s) */ + + static float cbfiltersTbl[]={ + (float)-0.034180, (float)0.108887, (float)-0.184326, + (float)0.806152, (float)0.713379, (float)-0.144043, + (float)0.083740, (float)-0.033691 + }; + + /* Gain Quantization */ + + static float gain_sq3Tbl[]={ + (float)-1.000000, (float)-0.659973, (float)-0.330017, + (float)0.000000, (float)0.250000, (float)0.500000, + (float)0.750000, (float)1.00000}; + + static float gain_sq4Tbl[]={ + (float)-1.049988, (float)-0.900024, (float)-0.750000, + (float)-0.599976, (float)-0.450012, (float)-0.299988, + (float)-0.150024, (float)0.000000, (float)0.150024, + (float)0.299988, (float)0.450012, (float)0.599976, + (float)0.750000, (float)0.900024, (float)1.049988, + (float)1.200012}; + + static float gain_sq5Tbl[]={ + (float)0.037476, (float)0.075012, (float)0.112488, + (float)0.150024, (float)0.187500, (float)0.224976, + (float)0.262512, (float)0.299988, (float)0.337524, + (float)0.375000, (float)0.412476, (float)0.450012, + (float)0.487488, (float)0.525024, (float)0.562500, + (float)0.599976, (float)0.637512, (float)0.674988, + (float)0.712524, (float)0.750000, (float)0.787476, + (float)0.825012, (float)0.862488, (float)0.900024, + (float)0.937500, (float)0.974976, (float)1.012512, + (float)1.049988, (float)1.087524, (float)1.125000, + (float)1.162476, (float)1.200012}; + + /* Enhancer - Upsamling a factor 4 (ENH_UPS0 = 4) */ + static float polyphaserTbl[]={ + (float)0.000000, (float)0.000000, (float)0.000000, + (float)1.000000, + (float)0.000000, (float)0.000000, (float)0.000000, + (float)0.015625, (float)-0.076904, (float)0.288330, + (float)0.862061, + (float)-0.106445, (float)0.018799, (float)-0.015625, + (float)0.023682, (float)-0.124268, (float)0.601563, + (float)0.601563, + (float)-0.124268, (float)0.023682, (float)-0.023682, + (float)0.018799, (float)-0.106445, (float)0.862061, + (float)0.288330, + (float)-0.076904, (float)0.015625, (float)-0.018799}; + + static float enh_plocsTbl[] = {(float)40.0f, (float)120.0f, + (float)200.0f, (float)280.0f, (float)360.0f, + (float)440.0f, (float)520.0f, (float)600.0}; + + /* LPC analysis and quantization */ + + static int dim_lsfCbTbl[] = {3, 3, 4}; + static int size_lsfCbTbl[] = {64,128,128}; + + static float lsfmeanTbl[] = { + (float)0.281738, (float)0.445801, (float)0.663330, + (float)0.962524, (float)1.251831, (float)1.533081, + (float)1.850586, (float)2.137817, (float)2.481445, + (float)2.777344}; + + static float lsf_weightTbl_30ms[] = {(float)(1.0f/2.0), (float)1.0, + (float)(2.0f/3.0), + (float)(1.0f/3.0), (float)0.0f, (float)0.0}; + + static float lsf_weightTbl_20ms[] = {(float)(3.0f/4.0), (float)(2.0/4.0), + (float)(1.0f/4.0), (float)(0.0)}; + + /* Hanning LPC window */ + static float lpc_winTbl[]={ + (float)0.000183, (float)0.000671, (float)0.001526, + (float)0.002716, (float)0.004242, (float)0.006104, + (float)0.008301, (float)0.010834, (float)0.013702, + (float)0.016907, (float)0.020416, (float)0.024261, + (float)0.028442, (float)0.032928, (float)0.037750, + (float)0.042877, (float)0.048309, (float)0.054047, + (float)0.060089, (float)0.066437, (float)0.073090, + (float)0.080017, (float)0.087219, (float)0.094727, + (float)0.102509, (float)0.110535, (float)0.118835, + (float)0.127411, (float)0.136230, (float)0.145294, + (float)0.154602, (float)0.164154, (float)0.173920, + (float)0.183899, (float)0.194122, (float)0.204529, + (float)0.215149, (float)0.225952, (float)0.236938, + (float)0.248108, (float)0.259460, (float)0.270966, + (float)0.282654, (float)0.294464, (float)0.306396, + (float)0.318481, (float)0.330688, (float)0.343018, + (float)0.355438, (float)0.367981, (float)0.380585, + (float)0.393280, (float)0.406067, (float)0.418884, + (float)0.431763, (float)0.444702, (float)0.457672, + (float)0.470673, (float)0.483704, (float)0.496735, + (float)0.509766, (float)0.522797, (float)0.535828, + (float)0.548798, (float)0.561768, (float)0.574677, + (float)0.587524, (float)0.600342, (float)0.613068, + (float)0.625732, (float)0.638306, (float)0.650787, + (float)0.663147, (float)0.675415, (float)0.687561, + (float)0.699585, (float)0.711487, (float)0.723206, + (float)0.734802, (float)0.746216, (float)0.757477, + (float)0.768585, (float)0.779480, (float)0.790192, + (float)0.800720, (float)0.811005, (float)0.821106, + (float)0.830994, (float)0.840668, (float)0.850067, + (float)0.859253, (float)0.868225, (float)0.876892, + (float)0.885345, (float)0.893524, (float)0.901428, + (float)0.909058, (float)0.916412, (float)0.923492, + (float)0.930267, (float)0.936768, (float)0.942963, + (float)0.948853, (float)0.954437, (float)0.959717, + (float)0.964691, (float)0.969360, (float)0.973694, + (float)0.977692, (float)0.981384, (float)0.984741, + (float)0.987762, (float)0.990479, (float)0.992828, + (float)0.994873, (float)0.996552, (float)0.997925, + (float)0.998932, (float)0.999603, (float)0.999969, + (float)0.999969, (float)0.999603, (float)0.998932, + (float)0.997925, (float)0.996552, (float)0.994873, + (float)0.992828, (float)0.990479, (float)0.987762, + (float)0.984741, (float)0.981384, (float)0.977692, + (float)0.973694, (float)0.969360, (float)0.964691, + (float)0.959717, (float)0.954437, (float)0.948853, + (float)0.942963, (float)0.936768, (float)0.930267, + (float)0.923492, (float)0.916412, (float)0.909058, + (float)0.901428, (float)0.893524, (float)0.885345, + (float)0.876892, (float)0.868225, (float)0.859253, + (float)0.850067, (float)0.840668, (float)0.830994, + (float)0.821106, (float)0.811005, (float)0.800720, + (float)0.790192, (float)0.779480, (float)0.768585, + (float)0.757477, (float)0.746216, (float)0.734802, + (float)0.723206, (float)0.711487, (float)0.699585, + (float)0.687561, (float)0.675415, (float)0.663147, + (float)0.650787, (float)0.638306, (float)0.625732, + (float)0.613068, (float)0.600342, (float)0.587524, + (float)0.574677, (float)0.561768, (float)0.548798, + (float)0.535828, (float)0.522797, (float)0.509766, + (float)0.496735, (float)0.483704, (float)0.470673, + (float)0.457672, (float)0.444702, (float)0.431763, + (float)0.418884, (float)0.406067, (float)0.393280, + (float)0.380585, (float)0.367981, (float)0.355438, + (float)0.343018, (float)0.330688, (float)0.318481, + (float)0.306396, (float)0.294464, (float)0.282654, + (float)0.270966, (float)0.259460, (float)0.248108, + (float)0.236938, (float)0.225952, (float)0.215149, + (float)0.204529, (float)0.194122, (float)0.183899, + (float)0.173920, (float)0.164154, (float)0.154602, + (float)0.145294, (float)0.136230, (float)0.127411, + (float)0.118835, (float)0.110535, (float)0.102509, + (float)0.094727, (float)0.087219, (float)0.080017, + (float)0.073090, (float)0.066437, (float)0.060089, + (float)0.054047, (float)0.048309, (float)0.042877, + (float)0.037750, (float)0.032928, (float)0.028442, + (float)0.024261, (float)0.020416, (float)0.016907, + (float)0.013702, (float)0.010834, (float)0.008301, + (float)0.006104, (float)0.004242, (float)0.002716, + (float)0.001526, (float)0.000671, (float)0.000183 + }; + + /* Asymmetric LPC window */ + static float lpc_asymwinTbl[]={ + (float)0.000061, (float)0.000214, (float)0.000458, + (float)0.000824, (float)0.001282, (float)0.001831, + (float)0.002472, (float)0.003235, (float)0.004120, + (float)0.005066, (float)0.006134, (float)0.007294, + (float)0.008545, (float)0.009918, (float)0.011383, + (float)0.012939, (float)0.014587, (float)0.016357, + (float)0.018219, (float)0.020172, (float)0.022217, + (float)0.024353, (float)0.026611, (float)0.028961, + (float)0.031372, (float)0.033905, (float)0.036530, + (float)0.039276, (float)0.042084, (float)0.044983, + (float)0.047974, (float)0.051086, (float)0.054260, + (float)0.057526, (float)0.060883, (float)0.064331, + (float)0.067871, (float)0.071503, (float)0.075226, + (float)0.079010, (float)0.082916, (float)0.086884, + (float)0.090942, (float)0.095062, (float)0.099304, + (float)0.103607, (float)0.107971, (float)0.112427, + (float)0.116974, (float)0.121582, (float)0.126282, + (float)0.131073, (float)0.135895, (float)0.140839, + (float)0.145813, (float)0.150879, (float)0.156006, + (float)0.161224, (float)0.166504, (float)0.171844, + (float)0.177246, (float)0.182709, (float)0.188263, + (float)0.193848, (float)0.199524, (float)0.205231, + (float)0.211029, (float)0.216858, (float)0.222778, + (float)0.228729, (float)0.234741, (float)0.240814, + (float)0.246918, (float)0.253082, (float)0.259308, + (float)0.265564, (float)0.271881, (float)0.278259, + (float)0.284668, (float)0.291107, (float)0.297607, + (float)0.304138, (float)0.310730, (float)0.317322, + (float)0.323975, (float)0.330658, (float)0.337372, + (float)0.344147, (float)0.350922, (float)0.357727, + (float)0.364594, (float)0.371460, (float)0.378357, + (float)0.385284, (float)0.392212, (float)0.399170, + (float)0.406158, (float)0.413177, (float)0.420197, + (float)0.427246, (float)0.434296, (float)0.441376, + (float)0.448456, (float)0.455536, (float)0.462646, + (float)0.469757, (float)0.476868, (float)0.483978, + (float)0.491089, (float)0.498230, (float)0.505341, + (float)0.512451, (float)0.519592, (float)0.526703, + (float)0.533813, (float)0.540924, (float)0.548004, + (float)0.555084, (float)0.562164, (float)0.569244, + (float)0.576294, (float)0.583313, (float)0.590332, + (float)0.597321, (float)0.604309, (float)0.611267, + (float)0.618195, (float)0.625092, (float)0.631989, + (float)0.638855, (float)0.645660, (float)0.652466, + (float)0.659241, (float)0.665985, (float)0.672668, + (float)0.679352, (float)0.685974, (float)0.692566, + (float)0.699127, (float)0.705658, (float)0.712128, + (float)0.718536, (float)0.724945, (float)0.731262, + (float)0.737549, (float)0.743805, (float)0.750000, + (float)0.756134, (float)0.762238, (float)0.768280, + (float)0.774261, (float)0.780182, (float)0.786072, + (float)0.791870, (float)0.797638, (float)0.803314, + (float)0.808960, (float)0.814514, (float)0.820038, + (float)0.825470, (float)0.830841, (float)0.836151, + (float)0.841400, (float)0.846558, (float)0.851654, + (float)0.856689, (float)0.861633, (float)0.866516, + (float)0.871338, (float)0.876068, (float)0.880737, + (float)0.885315, (float)0.889801, (float)0.894226, + (float)0.898560, (float)0.902832, (float)0.907013, + (float)0.911102, (float)0.915100, (float)0.919037, + (float)0.922882, (float)0.926636, (float)0.930328, + (float)0.933899, (float)0.937408, (float)0.940796, + (float)0.944122, (float)0.947357, (float)0.950470, + (float)0.953522, (float)0.956482, (float)0.959351, + (float)0.962097, (float)0.964783, (float)0.967377, + (float)0.969849, (float)0.972229, (float)0.974518, + (float)0.976715, (float)0.978821, (float)0.980835, + (float)0.982727, (float)0.984528, (float)0.986237, + (float)0.987854, (float)0.989380, (float)0.990784, + (float)0.992096, (float)0.993317, (float)0.994415, + (float)0.995422, (float)0.996338, (float)0.997162, + (float)0.997864, (float)0.998474, (float)0.998962, + (float)0.999390, (float)0.999695, (float)0.999878, + (float)0.999969, (float)0.999969, (float)0.996918, + (float)0.987701, (float)0.972382, (float)0.951050, + (float)0.923889, (float)0.891022, (float)0.852631, + (float)0.809021, (float)0.760406, (float)0.707092, + (float)0.649445, (float)0.587799, (float)0.522491, + (float)0.453979, (float)0.382690, (float)0.309021, + (float)0.233459, (float)0.156433, (float)0.078461 + }; + + /* Lag window for LPC */ + static float lpc_lagwinTbl[]={ + (float)1.000100, (float)0.998890, (float)0.995569, + (float)0.990057, (float)0.982392, + (float)0.972623, (float)0.960816, (float)0.947047, + (float)0.931405, (float)0.913989, (float)0.894909}; + + /* LSF quantization*/ + static float lsfCbTbl[] = { + (float)0.155396, (float)0.273193, (float)0.451172, + (float)0.390503, (float)0.648071, (float)1.002075, + (float)0.440186, (float)0.692261, (float)0.955688, + (float)0.343628, (float)0.642334, (float)1.071533, + (float)0.318359, (float)0.491577, (float)0.670532, + (float)0.193115, (float)0.375488, (float)0.725708, + (float)0.364136, (float)0.510376, (float)0.658691, + (float)0.297485, (float)0.527588, (float)0.842529, + (float)0.227173, (float)0.365967, (float)0.563110, + (float)0.244995, (float)0.396729, (float)0.636475, + (float)0.169434, (float)0.300171, (float)0.520264, + (float)0.312866, (float)0.464478, (float)0.643188, + (float)0.248535, (float)0.429932, (float)0.626099, + (float)0.236206, (float)0.491333, (float)0.817139, + (float)0.334961, (float)0.625122, (float)0.895752, + (float)0.343018, (float)0.518555, (float)0.698608, + (float)0.372803, (float)0.659790, (float)0.945435, + (float)0.176880, (float)0.316528, (float)0.581421, + (float)0.416382, (float)0.625977, (float)0.805176, + (float)0.303223, (float)0.568726, (float)0.915039, + (float)0.203613, (float)0.351440, (float)0.588135, + (float)0.221191, (float)0.375000, (float)0.614746, + (float)0.199951, (float)0.323364, (float)0.476074, + (float)0.300781, (float)0.433350, (float)0.566895, + (float)0.226196, (float)0.354004, (float)0.507568, + (float)0.300049, (float)0.508179, (float)0.711670, + (float)0.312012, (float)0.492676, (float)0.763428, + (float)0.329956, (float)0.541016, (float)0.795776, + (float)0.373779, (float)0.604614, (float)0.928833, + (float)0.210571, (float)0.452026, (float)0.755249, + (float)0.271118, (float)0.473267, (float)0.662476, + (float)0.285522, (float)0.436890, (float)0.634399, + (float)0.246704, (float)0.565552, (float)0.859009, + (float)0.270508, (float)0.406250, (float)0.553589, + (float)0.361450, (float)0.578491, (float)0.813843, + (float)0.342651, (float)0.482788, (float)0.622437, + (float)0.340332, (float)0.549438, (float)0.743164, + (float)0.200439, (float)0.336304, (float)0.540894, + (float)0.407837, (float)0.644775, (float)0.895142, + (float)0.294678, (float)0.454834, (float)0.699097, + (float)0.193115, (float)0.344482, (float)0.643188, + (float)0.275757, (float)0.420776, (float)0.598755, + (float)0.380493, (float)0.608643, (float)0.861084, + (float)0.222778, (float)0.426147, (float)0.676514, + (float)0.407471, (float)0.700195, (float)1.053101, + (float)0.218384, (float)0.377197, (float)0.669922, + (float)0.313232, (float)0.454102, (float)0.600952, + (float)0.347412, (float)0.571533, (float)0.874146, + (float)0.238037, (float)0.405396, (float)0.729492, + (float)0.223877, (float)0.412964, (float)0.822021, + (float)0.395264, (float)0.582153, (float)0.743896, + (float)0.247925, (float)0.485596, (float)0.720581, + (float)0.229126, (float)0.496582, (float)0.907715, + (float)0.260132, (float)0.566895, (float)1.012695, + (float)0.337402, (float)0.611572, (float)0.978149, + (float)0.267822, (float)0.447632, (float)0.769287, + (float)0.250610, (float)0.381714, (float)0.530029, + (float)0.430054, (float)0.805054, (float)1.221924, + (float)0.382568, (float)0.544067, (float)0.701660, + (float)0.383545, (float)0.710327, (float)1.149170, + (float)0.271362, (float)0.529053, (float)0.775513, + (float)0.246826, (float)0.393555, (float)0.588623, + (float)0.266846, (float)0.422119, (float)0.676758, + (float)0.311523, (float)0.580688, (float)0.838623, + (float)1.331177, (float)1.576782, (float)1.779541, + (float)1.160034, (float)1.401978, (float)1.768188, + (float)1.161865, (float)1.525146, (float)1.715332, + (float)0.759521, (float)0.913940, (float)1.119873, + (float)0.947144, (float)1.121338, (float)1.282471, + (float)1.015015, (float)1.557007, (float)1.804932, + (float)1.172974, (float)1.402100, (float)1.692627, + (float)1.087524, (float)1.474243, (float)1.665405, + (float)0.899536, (float)1.105225, (float)1.406250, + (float)1.148438, (float)1.484741, (float)1.796265, + (float)0.785645, (float)1.209839, (float)1.567749, + (float)0.867798, (float)1.166504, (float)1.450684, + (float)0.922485, (float)1.229858, (float)1.420898, + (float)0.791260, (float)1.123291, (float)1.409546, + (float)0.788940, (float)0.966064, (float)1.340332, + (float)1.051147, (float)1.272827, (float)1.556641, + (float)0.866821, (float)1.181152, (float)1.538818, + (float)0.906738, (float)1.373535, (float)1.607910, + (float)1.244751, (float)1.581421, (float)1.933838, + (float)0.913940, (float)1.337280, (float)1.539673, + (float)0.680542, (float)0.959229, (float)1.662720, + (float)0.887207, (float)1.430542, (float)1.800781, + (float)0.912598, (float)1.433594, (float)1.683960, + (float)0.860474, (float)1.060303, (float)1.455322, + (float)1.005127, (float)1.381104, (float)1.706909, + (float)0.800781, (float)1.363892, (float)1.829102, + (float)0.781860, (float)1.124390, (float)1.505981, + (float)1.003662, (float)1.471436, (float)1.684692, + (float)0.981323, (float)1.309570, (float)1.618042, + (float)1.228760, (float)1.554321, (float)1.756470, + (float)0.734375, (float)0.895752, (float)1.225586, + (float)0.841797, (float)1.055664, (float)1.249268, + (float)0.920166, (float)1.119385, (float)1.486206, + (float)0.894409, (float)1.539063, (float)1.828979, + (float)1.283691, (float)1.543335, (float)1.858276, + (float)0.676025, (float)0.933105, (float)1.490845, + (float)0.821289, (float)1.491821, (float)1.739868, + (float)0.923218, (float)1.144653, (float)1.580566, + (float)1.057251, (float)1.345581, (float)1.635864, + (float)0.888672, (float)1.074951, (float)1.353149, + (float)0.942749, (float)1.195435, (float)1.505493, + (float)1.492310, (float)1.788086, (float)2.039673, + (float)1.070313, (float)1.634399, (float)1.860962, + (float)1.253296, (float)1.488892, (float)1.686035, + (float)0.647095, (float)0.864014, (float)1.401855, + (float)0.866699, (float)1.254883, (float)1.453369, + (float)1.063965, (float)1.532593, (float)1.731323, + (float)1.167847, (float)1.521484, (float)1.884033, + (float)0.956055, (float)1.502075, (float)1.745605, + (float)0.928711, (float)1.288574, (float)1.479614, + (float)1.088013, (float)1.380737, (float)1.570801, + (float)0.905029, (float)1.186768, (float)1.371948, + (float)1.057861, (float)1.421021, (float)1.617432, + (float)1.108276, (float)1.312500, (float)1.501465, + (float)0.979492, (float)1.416992, (float)1.624268, + (float)1.276001, (float)1.661011, (float)2.007935, + (float)0.993042, (float)1.168579, (float)1.331665, + (float)0.778198, (float)0.944946, (float)1.235962, + (float)1.223755, (float)1.491333, (float)1.815674, + (float)0.852661, (float)1.350464, (float)1.722290, + (float)1.134766, (float)1.593140, (float)1.787354, + (float)1.051392, (float)1.339722, (float)1.531006, + (float)0.803589, (float)1.271240, (float)1.652100, + (float)0.755737, (float)1.143555, (float)1.639404, + (float)0.700928, (float)0.837280, (float)1.130371, + (float)0.942749, (float)1.197876, (float)1.669800, + (float)0.993286, (float)1.378296, (float)1.566528, + (float)0.801025, (float)1.095337, (float)1.298950, + (float)0.739990, (float)1.032959, (float)1.383667, + (float)0.845703, (float)1.072266, (float)1.543823, + (float)0.915649, (float)1.072266, (float)1.224487, + (float)1.021973, (float)1.226196, (float)1.481323, + (float)0.999878, (float)1.204102, (float)1.555908, + (float)0.722290, (float)0.913940, (float)1.340210, + (float)0.673340, (float)0.835938, (float)1.259521, + (float)0.832397, (float)1.208374, (float)1.394165, + (float)0.962158, (float)1.576172, (float)1.912842, + (float)1.166748, (float)1.370850, (float)1.556763, + (float)0.946289, (float)1.138550, (float)1.400391, + (float)1.035034, (float)1.218262, (float)1.386475, + (float)1.393799, (float)1.717773, (float)2.000244, + (float)0.972656, (float)1.260986, (float)1.760620, + (float)1.028198, (float)1.288452, (float)1.484619, + (float)0.773560, (float)1.258057, (float)1.756714, + (float)1.080322, (float)1.328003, (float)1.742676, + (float)0.823975, (float)1.450806, (float)1.917725, + (float)0.859009, (float)1.016602, (float)1.191895, + (float)0.843994, (float)1.131104, (float)1.645020, + (float)1.189697, (float)1.702759, (float)1.894409, + (float)1.346680, (float)1.763184, (float)2.066040, + (float)0.980469, (float)1.253784, (float)1.441650, + (float)1.338135, (float)1.641968, (float)1.932739, + (float)1.223267, (float)1.424194, (float)1.626465, + (float)0.765747, (float)1.004150, (float)1.579102, + (float)1.042847, (float)1.269165, (float)1.647461, + (float)0.968750, (float)1.257568, (float)1.555786, + (float)0.826294, (float)0.993408, (float)1.275146, + (float)0.742310, (float)0.950439, (float)1.430542, + (float)1.054321, (float)1.439819, (float)1.828003, + (float)1.072998, (float)1.261719, (float)1.441895, + (float)0.859375, (float)1.036377, (float)1.314819, + (float)0.895752, (float)1.267212, (float)1.605591, + (float)0.805420, (float)0.962891, (float)1.142334, + (float)0.795654, (float)1.005493, (float)1.468506, + (float)1.105347, (float)1.313843, (float)1.584839, + (float)0.792236, (float)1.221802, (float)1.465698, + (float)1.170532, (float)1.467651, (float)1.664063, + (float)0.838257, (float)1.153198, (float)1.342163, + (float)0.968018, (float)1.198242, (float)1.391235, + (float)1.250122, (float)1.623535, (float)1.823608, + (float)0.711670, (float)1.058350, (float)1.512085, + (float)1.204834, (float)1.454468, (float)1.739136, + (float)1.137451, (float)1.421753, (float)1.620117, + (float)0.820435, (float)1.322754, (float)1.578247, + (float)0.798706, (float)1.005005, (float)1.213867, + (float)0.980713, (float)1.324951, (float)1.512939, + (float)1.112305, (float)1.438843, (float)1.735596, + (float)1.135498, (float)1.356689, (float)1.635742, + (float)1.101318, (float)1.387451, (float)1.686523, + (float)0.849854, (float)1.276978, (float)1.523438, + (float)1.377930, (float)1.627563, (float)1.858154, + (float)0.884888, (float)1.095459, (float)1.287476, + (float)1.289795, (float)1.505859, (float)1.756592, + (float)0.817505, (float)1.384155, (float)1.650513, + (float)1.446655, (float)1.702148, (float)1.931885, + (float)0.835815, (float)1.023071, (float)1.385376, + (float)0.916626, (float)1.139038, (float)1.335327, + (float)0.980103, (float)1.174072, (float)1.453735, + (float)1.705688, (float)2.153809, (float)2.398315, (float)2.743408, + (float)1.797119, (float)2.016846, (float)2.445679, (float)2.701904, + (float)1.990356, (float)2.219116, (float)2.576416, (float)2.813477, + (float)1.849365, (float)2.190918, (float)2.611572, (float)2.835083, + (float)1.657959, (float)1.854370, (float)2.159058, (float)2.726196, + (float)1.437744, (float)1.897705, (float)2.253174, (float)2.655396, + (float)2.028687, (float)2.247314, (float)2.542358, (float)2.875854, + (float)1.736938, (float)1.922119, (float)2.185913, (float)2.743408, + (float)1.521606, (float)1.870972, (float)2.526855, (float)2.786987, + (float)1.841431, (float)2.050659, (float)2.463623, (float)2.857666, + (float)1.590088, (float)2.067261, (float)2.427979, (float)2.794434, + (float)1.746826, (float)2.057373, (float)2.320190, (float)2.800781, + (float)1.734619, (float)1.940552, (float)2.306030, (float)2.826416, + (float)1.786255, (float)2.204468, (float)2.457520, (float)2.795288, + (float)1.861084, (float)2.170532, (float)2.414551, (float)2.763672, + (float)2.001465, (float)2.307617, (float)2.552734, (float)2.811890, + (float)1.784424, (float)2.124146, (float)2.381592, (float)2.645508, + (float)1.888794, (float)2.135864, (float)2.418579, (float)2.861206, + (float)2.301147, (float)2.531250, (float)2.724976, (float)2.913086, + (float)1.837769, (float)2.051270, (float)2.261963, (float)2.553223, + (float)2.012939, (float)2.221191, (float)2.440186, (float)2.678101, + (float)1.429565, (float)1.858276, (float)2.582275, (float)2.845703, + (float)1.622803, (float)1.897705, (float)2.367310, (float)2.621094, + (float)1.581543, (float)1.960449, (float)2.515869, (float)2.736450, + (float)1.419434, (float)1.933960, (float)2.394653, (float)2.746704, + (float)1.721924, (float)2.059570, (float)2.421753, (float)2.769653, + (float)1.911011, (float)2.220703, (float)2.461060, (float)2.740723, + (float)1.581177, (float)1.860840, (float)2.516968, (float)2.874634, + (float)1.870361, (float)2.098755, (float)2.432373, (float)2.656494, + (float)2.059692, (float)2.279785, (float)2.495605, (float)2.729370, + (float)1.815674, (float)2.181519, (float)2.451538, (float)2.680542, + (float)1.407959, (float)1.768311, (float)2.343018, (float)2.668091, + (float)2.168701, (float)2.394653, (float)2.604736, (float)2.829346, + (float)1.636230, (float)1.865723, (float)2.329102, (float)2.824219, + (float)1.878906, (float)2.139526, (float)2.376709, (float)2.679810, + (float)1.765381, (float)1.971802, (float)2.195435, (float)2.586914, + (float)2.164795, (float)2.410889, (float)2.673706, (float)2.903198, + (float)2.071899, (float)2.331055, (float)2.645874, (float)2.907104, + (float)2.026001, (float)2.311523, (float)2.594849, (float)2.863892, + (float)1.948975, (float)2.180786, (float)2.514893, (float)2.797852, + (float)1.881836, (float)2.130859, (float)2.478149, (float)2.804199, + (float)2.238159, (float)2.452759, (float)2.652832, (float)2.868286, + (float)1.897949, (float)2.101685, (float)2.524292, (float)2.880127, + (float)1.856445, (float)2.074585, (float)2.541016, (float)2.791748, + (float)1.695557, (float)2.199097, (float)2.506226, (float)2.742676, + (float)1.612671, (float)1.877075, (float)2.435425, (float)2.732910, + (float)1.568848, (float)1.786499, (float)2.194580, (float)2.768555, + (float)1.953369, (float)2.164551, (float)2.486938, (float)2.874023, + (float)1.388306, (float)1.725342, (float)2.384521, (float)2.771851, + (float)2.115356, (float)2.337769, (float)2.592896, (float)2.864014, + (float)1.905762, (float)2.111328, (float)2.363525, (float)2.789307, + (float)1.882568, (float)2.332031, (float)2.598267, (float)2.827637, + (float)1.683594, (float)2.088745, (float)2.361938, (float)2.608643, + (float)1.874023, (float)2.182129, (float)2.536133, (float)2.766968, + (float)1.861938, (float)2.070435, (float)2.309692, (float)2.700562, + (float)1.722168, (float)2.107422, (float)2.477295, (float)2.837646, + (float)1.926880, (float)2.184692, (float)2.442627, (float)2.663818, + (float)2.123901, (float)2.337280, (float)2.553101, (float)2.777466, + (float)1.588135, (float)1.911499, (float)2.212769, (float)2.543945, + (float)2.053955, (float)2.370850, (float)2.712158, (float)2.939941, + (float)2.210449, (float)2.519653, (float)2.770386, (float)2.958618, + (float)2.199463, (float)2.474731, (float)2.718262, (float)2.919922, + (float)1.960083, (float)2.175415, (float)2.608032, (float)2.888794, + (float)1.953735, (float)2.185181, (float)2.428223, (float)2.809570, + (float)1.615234, (float)2.036499, (float)2.576538, (float)2.834595, + (float)1.621094, (float)2.028198, (float)2.431030, (float)2.664673, + (float)1.824951, (float)2.267456, (float)2.514526, (float)2.747925, + (float)1.994263, (float)2.229126, (float)2.475220, (float)2.833984, + (float)1.746338, (float)2.011353, (float)2.588257, (float)2.826904, + (float)1.562866, (float)2.135986, (float)2.471680, (float)2.687256, + (float)1.748901, (float)2.083496, (float)2.460938, (float)2.686279, + (float)1.758057, (float)2.131470, (float)2.636597, (float)2.891602, + (float)2.071289, (float)2.299072, (float)2.550781, (float)2.814331, + (float)1.839600, (float)2.094360, (float)2.496460, (float)2.723999, + (float)1.882202, (float)2.088257, (float)2.636841, (float)2.923096, + (float)1.957886, (float)2.153198, (float)2.384399, (float)2.615234, + (float)1.992920, (float)2.351196, (float)2.654419, (float)2.889771, + (float)2.012817, (float)2.262451, (float)2.643799, (float)2.903076, + (float)2.025635, (float)2.254761, (float)2.508423, (float)2.784058, + (float)2.316040, (float)2.589355, (float)2.794189, (float)2.963623, + (float)1.741211, (float)2.279541, (float)2.578491, (float)2.816284, + (float)1.845337, (float)2.055786, (float)2.348511, (float)2.822021, + (float)1.679932, (float)1.926514, (float)2.499756, (float)2.835693, + (float)1.722534, (float)1.946899, (float)2.448486, (float)2.728760, + (float)1.829834, (float)2.043213, (float)2.580444, (float)2.867676, + (float)1.676636, (float)2.071655, (float)2.322510, (float)2.704834, + (float)1.791504, (float)2.113525, (float)2.469727, (float)2.784058, + (float)1.977051, (float)2.215088, (float)2.497437, (float)2.726929, + (float)1.800171, (float)2.106689, (float)2.357788, (float)2.738892, + (float)1.827759, (float)2.170166, (float)2.525879, (float)2.852417, + (float)1.918335, (float)2.132813, (float)2.488403, (float)2.728149, + (float)1.916748, (float)2.225098, (float)2.542603, (float)2.857666, + (float)1.761230, (float)1.976074, (float)2.507446, (float)2.884521, + (float)2.053711, (float)2.367432, (float)2.608032, (float)2.837646, + (float)1.595337, (float)2.000977, (float)2.307129, (float)2.578247, + (float)1.470581, (float)2.031250, (float)2.375854, (float)2.647583, + (float)1.801392, (float)2.128052, (float)2.399780, (float)2.822876, + (float)1.853638, (float)2.066650, (float)2.429199, (float)2.751465, + (float)1.956299, (float)2.163696, (float)2.394775, (float)2.734253, + (float)1.963623, (float)2.275757, (float)2.585327, (float)2.865234, + (float)1.887451, (float)2.105469, (float)2.331787, (float)2.587402, + (float)2.120117, (float)2.443359, (float)2.733887, (float)2.941406, + (float)1.506348, (float)1.766968, (float)2.400513, (float)2.851807, + (float)1.664551, (float)1.981079, (float)2.375732, (float)2.774414, + (float)1.720703, (float)1.978882, (float)2.391479, (float)2.640991, + (float)1.483398, (float)1.814819, (float)2.434448, (float)2.722290, + (float)1.769043, (float)2.136597, (float)2.563721, (float)2.774414, + (float)1.810791, (float)2.049316, (float)2.373901, (float)2.613647, + (float)1.788330, (float)2.005981, (float)2.359131, (float)2.723145, + (float)1.785156, (float)1.993164, (float)2.399780, (float)2.832520, + (float)1.695313, (float)2.022949, (float)2.522583, (float)2.745117, + (float)1.584106, (float)1.965576, (float)2.299927, (float)2.715576, + (float)1.894897, (float)2.249878, (float)2.655884, (float)2.897705, + (float)1.720581, (float)1.995728, (float)2.299438, (float)2.557007, + (float)1.619385, (float)2.173950, (float)2.574219, (float)2.787964, + (float)1.883179, (float)2.220459, (float)2.474365, (float)2.825073, + (float)1.447632, (float)2.045044, (float)2.555542, (float)2.744873, + (float)1.502686, (float)2.156616, (float)2.653320, (float)2.846558, + (float)1.711548, (float)1.944092, (float)2.282959, (float)2.685791, + (float)1.499756, (float)1.867554, (float)2.341064, (float)2.578857, + (float)1.916870, (float)2.135132, (float)2.568237, (float)2.826050, + (float)1.498047, (float)1.711182, (float)2.223267, (float)2.755127, + (float)1.808716, (float)1.997559, (float)2.256470, (float)2.758545, + (float)2.088501, (float)2.402710, (float)2.667358, (float)2.890259, + (float)1.545044, (float)1.819214, (float)2.324097, (float)2.692993, + (float)1.796021, (float)2.012573, (float)2.505737, (float)2.784912, + (float)1.786499, (float)2.041748, (float)2.290405, (float)2.650757, + (float)1.938232, (float)2.264404, (float)2.529053, (float)2.796143 + }; + +} + diff --git a/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/ilbc_decoder.java b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/ilbc_decoder.java new file mode 100644 index 0000000..79973b1 --- /dev/null +++ b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/ilbc_decoder.java @@ -0,0 +1,2048 @@ +/* + * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client. + * + * Distributable under LGPL license. + * See terms of license at gnu.org. + */ +package net.java.sip.communicator.impl.media.codec.audio.ilbc; + +import java.lang.*; + +/** + * @author Jean Lorchat + */ +class ilbc_decoder { + + int consPLICount; + int prevPLI; + int prevLag; + int last_lag; + int prev_enh_pl; + float per; + float prevResidual[]; + long seed; + float prevLpc[]; + + ilbc_ulp ULP_inst = null; + + float syntMem[]; + float lsfdeqold[]; + float old_syntdenum[]; + float hpomem[]; + int use_enhancer; + float enh_buf[]; + float enh_period[]; + + // La plupart des variables globales sont dans ilbc_constants.etc... + + + void syntFilter( + float Out[], /* (i/o) Signal to be filtered */ + int Out_idx, + float a[], /* (i) LP parameters */ + int a_idx, + int len, /* (i) Length of signal */ + float mem[]) /* (i/o) Filter state */ + { + int i, j; + // float *po, *pi, *pa, *pm; + int po, pi, pa, pm; + +// System.out.println("out size : " + Out.length); +// System.out.println("out idx : " + Out_idx); +// System.out.println("a size : " + a.length); +// System.out.println("a idx : " + a_idx); +// System.out.println("len : " + len); +// System.out.println("mem size : " + mem.length); + + po = Out_idx; + + /* Filter first part using memory from past */ + + for (i=0; i<ilbc_constants.LPC_FILTERORDER; i++) { +// pi=&Out[i-1]; +// pa=&a[1]; +// pm=&mem[LPC_FILTERORDER-1]; + pi = Out_idx + i - 1; + pa = a_idx + 1; + pm = ilbc_constants.LPC_FILTERORDER - 1; + + for (j=1; j<=i; j++) { + // *po-=(*pa++)*(*pi--); +// System.out.println("1 Soustraction (" + i + "," + j + ") a " + Out[po] + " de " + a[pa] + " * " + Out[pi]); +// System.out.println("index " + (po - Out_idx) + " <> " + (pi - Out_idx)); + Out[po] -= a[pa] * Out[pi]; +// System.out.println("Pour un resultat de " + Out[po]); + pa++; + pi--; + } + for (j=i+1; j < ilbc_constants.LPC_FILTERORDER+1; j++) { + // *po-=(*pa++)*(*pm--); +// System.out.println("2 Soustraction a " + Out[po] + " de " + a[pa] + " * " + mem[pm]); + Out[po] -= a[pa] * mem[pm]; +// System.out.println("Pour un resultat de " + Out[po]); + pa++; + pm--; + } + po++; + } + + /* Filter last part where the state is entirely in + the output vector */ + + for (i = ilbc_constants.LPC_FILTERORDER; i < len; i++) { + // pi=&Out[i-1]; + pi = Out_idx + i - 1; + // pa=&a[1]; + pa = a_idx + 1; + for (j=1; j < ilbc_constants.LPC_FILTERORDER+1; j++) { + // *po-=(*pa++)*(*pi--); +// System.out.println("3 Soustraction a " + Out[po] + " de " + a[pa] + " * " + Out[pi]); + Out[po] -= a[pa] * Out[pi]; +// System.out.println("Pour un resultat de " + Out[po]); + pa++; + pi--; + } + po++; + } + + /* Update state vector */ + + System.arraycopy(Out, Out_idx + len - ilbc_constants.LPC_FILTERORDER, + mem, 0, ilbc_constants.LPC_FILTERORDER); +// memcpy(mem, &Out[len-LPC_FILTERORDER], +// LPC_FILTERORDER*sizeof(float)); + } + + /*---------------------------------------------------------------* + * interpolation of lsf coefficients for the decoder + *--------------------------------------------------------------*/ + + public void LSFinterpolate2a_dec( + float a[], /* (o) lpc coefficients for a sub-frame */ + float lsf1[], /* (i) first lsf coefficient vector */ + float lsf2[], /* (i) second lsf coefficient vector */ + int lsf2_idx, + float coef, /* (i) interpolation weight */ + int length /* (i) length of lsf vectors */ + ){ + float [] lsftmp = new float[ilbc_constants.LPC_FILTERORDER]; + + ilbc_common.interpolate(lsftmp, lsf1, lsf2, lsf2_idx, coef, length); + ilbc_common.lsf2a(a, lsftmp); + } + + /*---------------------------------------------------------------* + * obtain dequantized lsf coefficients from quantization index + *--------------------------------------------------------------*/ + + void SimplelsfDEQ( + float lsfdeq[], /* (o) dequantized lsf coefficients */ + int index[], /* (i) quantization index */ + int lpc_n /* (i) number of LPCs */ + ){ + int i, j, pos, cb_pos; + + /* decode first LSF */ + + pos = 0; + cb_pos = 0; + for (i = 0; i < ilbc_constants.LSF_NSPLIT; i++) { + for (j = 0; j < ilbc_constants.dim_lsfCbTbl[i]; j++) { + lsfdeq[pos + j] = ilbc_constants.lsfCbTbl[cb_pos + (int) + ((long)(index[i])*ilbc_constants.dim_lsfCbTbl[i] + j)]; + } + pos += ilbc_constants.dim_lsfCbTbl[i]; + cb_pos += ilbc_constants.size_lsfCbTbl[i]*ilbc_constants.dim_lsfCbTbl[i]; + } + + if (lpc_n>1) { + + /* decode last LSF */ + + pos = 0; + cb_pos = 0; + for (i = 0; i < ilbc_constants.LSF_NSPLIT; i++) { + for (j = 0; j < ilbc_constants.dim_lsfCbTbl[i]; j++) { + lsfdeq[ilbc_constants.LPC_FILTERORDER + pos + j] = + ilbc_constants.lsfCbTbl[cb_pos + (int) + ((long)(index[ilbc_constants.LSF_NSPLIT + i])* + ilbc_constants.dim_lsfCbTbl[i]) + j]; + } + pos += ilbc_constants.dim_lsfCbTbl[i]; + cb_pos += ilbc_constants.size_lsfCbTbl[i]*ilbc_constants.dim_lsfCbTbl[i]; + } + } + } + + /*----------------------------------------------------------------* + * obtain synthesis and weighting filters form lsf coefficients + *---------------------------------------------------------------*/ + + void DecoderInterpolateLSF( + float syntdenum[], /* (o) synthesis filter coefficients */ + float weightdenum[], /* (o) weighting denumerator + coefficients */ + float lsfdeq[], /* (i) dequantized lsf coefficients */ + int length) /* (i) length of lsf coefficient vector */ + { + int i, pos, lp_length; + float [] lp = new float[ilbc_constants.LPC_FILTERORDER + 1]; + int lsfdeq2; + + lsfdeq2 = length; +// lsfdeq2 = lsfdeq + length; + lp_length = length + 1; + + if (this.ULP_inst.mode==30) { + /* sub-frame 1: Interpolation between old and first */ + + LSFinterpolate2a_dec(lp, this.lsfdeqold, lsfdeq, 0, + ilbc_constants.lsf_weightTbl_30ms[0], length); + System.arraycopy(lp, 0, syntdenum, 0, lp_length); +// memcpy(syntdenum,lp,lp_length*sizeof(float)); + ilbc_common.bwexpand(weightdenum, 0, lp, ilbc_constants.LPC_CHIRP_WEIGHTDENUM, lp_length); + + /* sub-frames 2 to 6: interpolation between first + and last LSF */ + + pos = lp_length; + for (i = 1; i < 6; i++) { + LSFinterpolate2a_dec(lp, lsfdeq, lsfdeq, lsfdeq2, + ilbc_constants.lsf_weightTbl_30ms[i], length); + System.arraycopy(lp, 0, syntdenum, pos, lp_length); +// memcpy(syntdenum + pos,lp,lp_length*sizeof(float)); + ilbc_common.bwexpand(weightdenum, pos, lp, + ilbc_constants.LPC_CHIRP_WEIGHTDENUM, lp_length); + pos += lp_length; + } + } + else { + pos = 0; + for (i = 0; i < this.ULP_inst.nsub; i++) { + LSFinterpolate2a_dec(lp, this.lsfdeqold, + lsfdeq, 0, ilbc_constants.lsf_weightTbl_20ms[i], length); + System.arraycopy(lp, 0, syntdenum, pos, lp_length); +// memcpy(syntdenum+pos,lp,lp_length*sizeof(float)); + ilbc_common.bwexpand(weightdenum, pos, lp, ilbc_constants.LPC_CHIRP_WEIGHTDENUM, + lp_length); + pos += lp_length; + } + } + + /* update memory */ + + if (this.ULP_inst.mode==30) { + System.arraycopy(lsfdeq, lsfdeq2, this.lsfdeqold, 0, length); +// memcpy(iLBCdec_inst->lsfdeqold, lsfdeq2, length*sizeof(float)); + } else { + System.arraycopy(lsfdeq, 0, this.lsfdeqold, 0, length); +// memcpy(iLBCdec_inst->lsfdeqold, lsfdeq, length*sizeof(float)); + } + } + + + public void index_conv_dec(int index[]) /* (i/o) Codebook indexes */ + { + int k; + + for (k=1; k<ilbc_constants.CB_NSTAGES; k++) { + + if ((index[k]>=44)&&(index[k]<108)) { + index[k]+=64; + } else if ((index[k]>=108)&&(index[k]<128)) { + index[k]+=128; + } else { + /* ERROR */ + } + } + } + + public void hpOutput( + float In[], /* (i) vector to filter */ + int len,/* (i) length of vector to filter */ + float Out[], /* (o) the resulting filtered vector */ + float mem[]) /* (i/o) the filter state */ + { + int i; + // float *pi, *po; + int pi, po; + + /* all-zero section*/ + +// pi = &In[0]; +// po = &Out[0]; + pi = 0; + po = 0; + + for (i=0; i<len; i++) { + Out[po] = ilbc_constants.hpo_zero_coefsTbl[0] * (In[pi]); + Out[po] += ilbc_constants.hpo_zero_coefsTbl[1] * mem[0]; + Out[po] += ilbc_constants.hpo_zero_coefsTbl[2] * mem[1]; + + mem[1] = mem[0]; + mem[0] = In[pi]; + po++; + pi++; + + } + + /* all-pole section*/ + + // po = &Out[0]; + po = 0; + for (i=0; i<len; i++) { + Out[po] -= ilbc_constants.hpo_pole_coefsTbl[1] * mem[2]; + Out[po] -= ilbc_constants.hpo_pole_coefsTbl[2] * mem[3]; + + mem[3] = mem[2]; + mem[2] = Out[po]; + po++; + } + } + + /*----------------------------------------------------------------* + * downsample (LP filter and decimation) + *---------------------------------------------------------------*/ + + void DownSample ( + float In[], /* (i) input samples */ + int in_idx, + float Coef[], /* (i) filter coefficients */ + int lengthIn, /* (i) number of input samples */ + float state[], /* (i) filter state */ + float Out[]) /* (o) downsampled output */ + { + float o; + // float *Out_ptr = Out; + int out_ptr = 0; + //float *Coef_ptr, *In_ptr; + int coef_ptr = 0; + int in_ptr = in_idx; + //float *state_ptr; + int state_ptr = 0; + int i, j, stop; + + /* LP filter and decimate at the same time */ + + for (i = ilbc_constants.DELAY_DS; i < lengthIn; i += ilbc_constants.FACTOR_DS) + { + coef_ptr = 0; + in_ptr = in_idx + i; + state_ptr = ilbc_constants.FILTERORDER_DS - 2; + + o = (float)0.0f; + + // stop = (i < ilbc_constants.FILTERORDER_DS) ? i + 1 : ilbc_constants.FILTERORDER_DS; + if (i < ilbc_constants.FILTERORDER_DS) { + stop = i + 1; + } + else { + stop = ilbc_constants.FILTERORDER_DS; + } + + for (j = 0; j < stop; j++) + { + o += Coef[coef_ptr] * In[in_ptr]; + coef_ptr++; + in_ptr--; + } + for (j = i + 1; j < ilbc_constants.FILTERORDER_DS; j++) + { + o += Coef[coef_ptr] * state[state_ptr]; + coef_ptr++; + state_ptr--; + } + Out[out_ptr] = o; + out_ptr++; + // *Out_ptr++ = o; + } + + /* Get the last part (use zeros as input for the future) */ + + for (i=(lengthIn+ilbc_constants.FACTOR_DS); i<(lengthIn+ilbc_constants.DELAY_DS); + i+=ilbc_constants.FACTOR_DS) { + + o=(float)0.0f; + + if (i<lengthIn) { + coef_ptr = 0; + in_ptr = in_idx + i; + for (j=0; j<ilbc_constants.FILTERORDER_DS; j++) { + o += Coef[coef_ptr] * Out[out_ptr]; + coef_ptr++; + out_ptr--; + // o += *Coef_ptr++ * (*Out_ptr--); + } + } else { + coef_ptr = i-lengthIn; + in_ptr = in_idx + lengthIn - 1; + for (j=0; j<ilbc_constants.FILTERORDER_DS-(i-lengthIn); j++) { + o += Coef[coef_ptr] * In[in_ptr]; + coef_ptr++; + in_ptr--; + } + } + Out[out_ptr] = o; + out_ptr++; + } + } + + /*----------------------------------------------------------------* + * Find index in array such that the array element with said + * index is the element of said array closest to "value" + * according to the squared-error criterion + *---------------------------------------------------------------*/ + + public int NearestNeighbor( +// int index[], /* (o) index of array element closest +// to value */ + float array[], /* (i) data array */ + float value,/* (i) value */ + int arlength)/* (i) dimension of data array */ + { + int i; + float bestcrit,crit; + int index; + + crit = array[0] - value; + bestcrit = crit * crit; + index = 0; + for (i = 1; i < arlength; i++) { + crit = array[i] - value; + crit = crit * crit; + + if (crit < bestcrit) { + bestcrit = crit; + index = i; + } + } + return index; + } + + /*----------------------------------------------------------------* + * compute cross correlation between sequences + *---------------------------------------------------------------*/ + + public void mycorr1( + float corr[], /* (o) correlation of seq1 and seq2 */ + int corr_idx, + float seq1[], /* (i) first sequence */ + int seq1_idx, + int dim1, /* (i) dimension first seq1 */ + float seq2[], /* (i) second sequence */ + int seq2_idx, + int dim2) /* (i) dimension seq2 */ + { + int i,j; + +// System.out.println("longueur 1 : " + seq1.length); +// System.out.println("distance 1 : " + seq1_idx); +// System.out.println("longueur 2 : " + seq2.length); +// System.out.println("distance 2 : " + seq2_idx); + +// System.out.println("dimensions : " + dim1 + " et " + dim2); + +// BUG in ILBC ??? + + for (i=0; i<=dim1-dim2; i++) { + if ((corr_idx+i) < corr.length) + corr[corr_idx+i]=0.0f; + for (j=0; j<dim2; j++) { + corr[corr_idx+i] += seq1[seq1_idx+i+j] * seq2[seq2_idx+j]; + } + } + } + + /*----------------------------------------------------------------* + * upsample finite array assuming zeros outside bounds + *---------------------------------------------------------------*/ + + public void enh_upsample( + float useq1[], /* (o) upsampled output sequence */ + float seq1[],/* (i) unupsampled sequence */ + int dim1, /* (i) dimension seq1 */ + int hfl) /* (i) polyphase filter length=2*hfl+1 */ + { + // float *pu,*ps; + int pu, ps; + int i,j,k,q,filterlength,hfl2; + int [] polyp = new int[ilbc_constants.ENH_UPS0]; /* pointers to + polyphase columns */ + // const float *pp; + int pp; + + /* define pointers for filter */ + + filterlength=2*hfl+1; + + if ( filterlength > dim1 ) { + hfl2=(int) (dim1/2); + for (j=0; j<ilbc_constants.ENH_UPS0; j++) { + polyp[j]=j*filterlength+hfl-hfl2; + } + hfl=hfl2; + filterlength=2*hfl+1; + } + else { + for (j=0; j<ilbc_constants.ENH_UPS0; j++) { + polyp[j]=j*filterlength; + } + } + + /* filtering: filter overhangs left side of sequence */ + + // pu=useq1; + pu = 0; + for (i=hfl; i<filterlength; i++) { + for (j=0; j<ilbc_constants.ENH_UPS0; j++) { + // *pu=0.0f; + useq1[pu] = 0.0f; + // pp = polyp[j]; + pp = polyp[j]; + // ps = seq1+i; + ps = i; + for (k=0; k<=i; k++) { + useq1[pu] += seq1[ps] * ilbc_constants.polyphaserTbl[pp]; + ps--; + pp++; + } + pu++; + } + } + + /* filtering: simple convolution=inner products */ + + for (i=filterlength; i<dim1; i++) { + for (j=0;j < ilbc_constants.ENH_UPS0; j++){ + // *pu=0.0f; + useq1[pu] = 0.0f; + // pp = polyp[j]; + pp = polyp[j]; + // ps = seq1+i; + ps = i; + for (k=0; k<filterlength; k++) { + // *pu += *ps-- * *pp++; + useq1[pu] += seq1[ps] * ilbc_constants.polyphaserTbl[pp]; + ps--; + pp++; + } + pu++; + } + } + + /* filtering: filter overhangs right side of sequence */ + + for (q=1; q<=hfl; q++) { + for (j=0; j<ilbc_constants.ENH_UPS0; j++) { + // *pu=0.0f; + useq1[pu] = 0.0f; + // pp = polyp[j]+q; + pp = polyp[j]+q; + // ps = seq1+dim1-1; + ps = dim1 - 1; + for (k=0; k<filterlength-q; k++) { + useq1[pu] += seq1[ps] * ilbc_constants.polyphaserTbl[pp]; + ps--; + pp++; + // *pu += *ps-- * *pp++; + } + pu++; + } + } + } + + + /*----------------------------------------------------------------* + * find segment starting near idata+estSegPos that has highest + * correlation with idata+centerStartPos through + * idata+centerStartPos+ENH_BLOCKL-1 segment is found at a + * resolution of ENH_UPSO times the original of the original + * sampling rate + *---------------------------------------------------------------*/ + + public float refiner( + float seg[], /* (o) segment array */ + int seg_idx, + float idata[], /* (i) original data buffer */ + int idatal, /* (i) dimension of idata */ + int centerStartPos, /* (i) beginning center segment */ + float estSegPos,/* (i) estimated beginning other segment */ + float period) /* (i) estimated pitch period */ + { + int estSegPosRounded,searchSegStartPos,searchSegEndPos,corrdim; + int tloc,tloc2,i,st,en,fraction; + float [] vect = new float[ilbc_constants.ENH_VECTL]; + float [] corrVec = new float[ilbc_constants.ENH_CORRDIM]; + float maxv; + float [] corrVecUps = new float[ilbc_constants.ENH_CORRDIM*ilbc_constants.ENH_UPS0]; + float updStartPos = 0.0f; + + /* defining array bounds */ + + estSegPosRounded=(int)(estSegPos - 0.5); + + searchSegStartPos=estSegPosRounded-ilbc_constants.ENH_SLOP; + + if (searchSegStartPos<0) { + searchSegStartPos=0; + } + searchSegEndPos=estSegPosRounded+ilbc_constants.ENH_SLOP; + + if (searchSegEndPos+ilbc_constants.ENH_BLOCKL >= idatal) { + searchSegEndPos=idatal-ilbc_constants.ENH_BLOCKL-1; + } + corrdim=searchSegEndPos-searchSegStartPos+1; + + /* compute upsampled correlation (corr33) and find + location of max */ +// System.out.println("appel 1"); + mycorr1(corrVec, 0, idata, searchSegStartPos, + corrdim+ilbc_constants.ENH_BLOCKL-1, + idata,centerStartPos,ilbc_constants.ENH_BLOCKL); + enh_upsample(corrVecUps,corrVec,corrdim,ilbc_constants.ENH_FL0); + tloc=0; maxv=corrVecUps[0]; + for (i=1; i<ilbc_constants.ENH_UPS0*corrdim; i++) { + + if (corrVecUps[i]>maxv) { + tloc=i; + maxv=corrVecUps[i]; + } + } + + /* make vector can be upsampled without ever running outside + bounds */ + + updStartPos= (float)searchSegStartPos + + (float)tloc/(float)ilbc_constants.ENH_UPS0+(float)1.0f; + tloc2=(int)(tloc/ilbc_constants.ENH_UPS0); + + if (tloc>tloc2*ilbc_constants.ENH_UPS0) { + tloc2++; + } + st=searchSegStartPos+tloc2-ilbc_constants.ENH_FL0; + + if (st<0) { + for (int li = 0; li < -st; li++) + vect[li] = 0.0f; +// memset(vect,0,-st*sizeof(float)); + System.arraycopy(idata, 0, vect, -st, (ilbc_constants.ENH_VECTL+st)); +// memcpy(&vect[-st],idata, (ilbc_constants.ENH_VECTL+st)*sizeof(float)); + } + else { + en=st+ilbc_constants.ENH_VECTL; + + if (en>idatal) { + System.arraycopy(idata, st, vect, 0, (ilbc_constants.ENH_VECTL-(en-idatal))); +// memcpy(vect, &idata[st], +// (ilbc_constants.ENH_VECTL-(en-idatal))*sizeof(float)); + for (int li = 0; li < en-idatal; li++) + vect[ilbc_constants.ENH_VECTL-(en-idatal)+li] = 0.0f; +// memset(&vect[ilbc_constants.ENH_VECTL-(en-idatal)], 0, +// (en-idatal)*sizeof(float)); + } + else { + System.arraycopy(idata, st, vect, 0, ilbc_constants.ENH_VECTL); +// memcpy(vect, &idata[st], ilbc_constants.ENH_VECTL*sizeof(float)); + } + } + fraction=tloc2*ilbc_constants.ENH_UPS0-tloc; + + /* compute the segment (this is actually a convolution) */ + +// System.out.println("appel 2"); +// System.out.println("longueur 1 : " + vect.length); +// System.out.println("distance 1 : " + 0); +// System.out.println("longueur 2 : " + ilbc_constants.polyphaserTbl.length); +// System.out.println("distance 2 : " + (2*ilbc_constants.ENH_FL0+1)*fraction); +// System.out.println("dimension 1 : " + ilbc_constants.ENH_VECTL); +// System.out.println("dimension 2 : " + (2 * ilbc_constants.ENH_FL0+1)); +// System.out.println("correlations de dimension " + seg.length); + mycorr1(seg, seg_idx, vect, 0, ilbc_constants.ENH_VECTL, + ilbc_constants.polyphaserTbl, + (2*ilbc_constants.ENH_FL0+1)*fraction, + 2*ilbc_constants.ENH_FL0+1); + + return updStartPos; + } + + /*----------------------------------------------------------------* + * find the smoothed output data + *---------------------------------------------------------------*/ + + public void smath( + float odata[], /* (o) smoothed output */ + int odata_idx, + float sseq[],/* (i) said second sequence of waveforms */ + int hl, /* (i) 2*hl+1 is sseq dimension */ + float alpha0)/* (i) max smoothing energy fraction */ + { + int i,k; + float w00,w10,w11,A,B,C,err,errs; + float [] surround = new float[ilbc_constants.BLOCKL_MAX]; /* shape contributed by other than + current */ + float [] wt = new float[2*ilbc_constants.ENH_HL+1]; /* waveform weighting to get + surround shape */ + float denom; + int psseq; + + /* create shape of contribution from all waveforms except the + current one */ + + for (i=1; i<=2*hl+1; i++) { + wt[i-1] = (float)0.5*(1 - (float)(float)Math.cos(2*ilbc_constants.PI*i/(2*hl+2))); + } + wt[hl]=0.0f; /* for clarity, not used */ + for (i=0; i<ilbc_constants.ENH_BLOCKL; i++) { + surround[i]=sseq[i]*wt[0]; + } + for (k=1; k<hl; k++) { + psseq=k*ilbc_constants.ENH_BLOCKL; + for(i=0;i<ilbc_constants.ENH_BLOCKL; i++) { + surround[i]+=sseq[psseq+i]*wt[k]; + } + } + for (k=hl+1; k<=2*hl; k++) { + psseq=k*ilbc_constants.ENH_BLOCKL; + for(i=0;i<ilbc_constants.ENH_BLOCKL; i++) { + surround[i]+=sseq[psseq+i]*wt[k]; + } + } + + /* compute some inner products */ + + w00 = w10 = w11 = 0.0f; + psseq=hl*ilbc_constants.ENH_BLOCKL; /* current block */ + for (i=0; i<ilbc_constants.ENH_BLOCKL;i++) { + w00+=sseq[psseq+i]*sseq[psseq+i]; + w11+=surround[i]*surround[i]; + w10+=surround[i]*sseq[psseq+i]; + } + + if ((float)Math.abs(w11) < 1.0f) { + w11=1.0f; + } + C = (float)(float)Math.sqrt( w00/w11); + + /* first try enhancement without power-constraint */ + + errs=0.0f; + psseq=hl*ilbc_constants.ENH_BLOCKL; + for (i=0; i<ilbc_constants.ENH_BLOCKL; i++) { + odata[odata_idx+i]=C*surround[i]; + err=sseq[psseq+i]-odata[odata_idx+i]; + errs+=err*err; + } + + /* if constraint violated by first try, add constraint */ + + if (errs > alpha0 * w00) { + if ( w00 < 1) { + w00=1; + } + denom = (w11*w00-w10*w10)/(w00*w00); + + if (denom > 0.0001f) { /* eliminates numerical problems + for if smooth */ + A = (float)(float)Math.sqrt( (alpha0- alpha0*alpha0/4)/denom); + B = -alpha0/2 - A * w10/w00; + B = B+1; + } + else { /* essentially no difference between cycles; + smoothing not needed */ + A= 0.0f; + B= 1.0f; + } + + /* create smoothed sequence */ + + psseq=hl*ilbc_constants.ENH_BLOCKL; + for (i=0; i<ilbc_constants.ENH_BLOCKL; i++) { + odata[odata_idx + i]=A*surround[i]+B*sseq[psseq+i]; + } + } + } + + /*----------------------------------------------------------------* + * get the pitch-synchronous sample sequence + *---------------------------------------------------------------*/ + + public void getsseq( + float sseq[], /* (o) the pitch-synchronous sequence */ + float idata[], /* (i) original data */ + int idatal, /* (i) dimension of data */ + int centerStartPos, /* (i) where current block starts */ + float period[], /* (i) rough-pitch-period array */ + float plocs[], /* (i) where periods of period array + are taken */ + int periodl, /* (i) dimension period array */ + int hl) /* (i) 2*hl+1 is the number of sequences */ + { + int i,centerEndPos,q; + float [] blockStartPos = new float[2*ilbc_constants.ENH_HL+1]; + int [] lagBlock = new int[2*ilbc_constants.ENH_HL+1]; + float [] plocs2 = new float[ilbc_constants.ENH_PLOCSL]; + // float *psseq; + int psseq; + + centerEndPos=centerStartPos+ilbc_constants.ENH_BLOCKL-1; + + /* present */ + + lagBlock[hl] = NearestNeighbor(plocs, + (float)0.5*(centerStartPos+centerEndPos),periodl); + + blockStartPos[hl]=(float)centerStartPos; + + psseq=ilbc_constants.ENH_BLOCKL*hl; +// psseq=sseq+ENH_BLOCKL*hl; + System.arraycopy(idata, centerStartPos, sseq, psseq, ilbc_constants.ENH_BLOCKL); +// memcpy(psseq, idata+centerStartPos, ENH_BLOCKL*sizeof(float)); + + /* past */ + + for (q=hl-1; q>=0; q--) { + blockStartPos[q]=blockStartPos[q+1]-period[lagBlock[q+1]]; + lagBlock[q] = NearestNeighbor(plocs, + blockStartPos[q]+ + ilbc_constants.ENH_BLOCKL_HALF-period[lagBlock[q+1]], + periodl); + + + if (blockStartPos[q]-ilbc_constants.ENH_OVERHANG>=0) { + blockStartPos[q] = refiner(sseq,q*ilbc_constants.ENH_BLOCKL, idata, + idatal, centerStartPos, + blockStartPos[q], + period[lagBlock[q+1]]); + } else { + psseq=q*ilbc_constants.ENH_BLOCKL; +// psseq=sseq+q*ENH_BLOCKL; + for (int li = 0; li < ilbc_constants.ENH_BLOCKL; li++) + sseq[psseq+li] = 0.0f; +// memset(psseq, 0, ENH_BLOCKL*sizeof(float)); + } + } + + /* future */ + + for (i=0; i<periodl; i++) { + plocs2[i]=plocs[i]-period[i]; + } + for (q=hl+1; q<=2*hl; q++) { + lagBlock[q] = NearestNeighbor(plocs2, + blockStartPos[q-1]+ilbc_constants.ENH_BLOCKL_HALF, + periodl); + + blockStartPos[q]=blockStartPos[q-1]+period[lagBlock[q]]; + if (blockStartPos[q]+ilbc_constants.ENH_BLOCKL+ilbc_constants.ENH_OVERHANG<idatal) { + blockStartPos[q] = refiner(sseq,q*ilbc_constants.ENH_BLOCKL, idata, + idatal, centerStartPos, + blockStartPos[q], + period[lagBlock[q]]); + } + else { + psseq=q*ilbc_constants.ENH_BLOCKL; +// psseq=sseq+q*ENH_BLOCKL; + for (int li = 0; li < ilbc_constants.ENH_BLOCKL; li++) + sseq[psseq+li] = 0.0f; +// memset(psseq, 0, ENH_BLOCKL*sizeof(float)); + } + } + } + + /*----------------------------------------------------------------* + * perform enhancement on idata+centerStartPos through + * idata+centerStartPos+ENH_BLOCKL-1 + *---------------------------------------------------------------*/ + + public void enhancer( + float odata[], /* (o) smoothed block, dimension blockl */ + int odata_idx, + float idata[], /* (i) data buffer used for enhancing */ + int idatal, /* (i) dimension idata */ + int centerStartPos, /* (i) first sample current block + within idata */ + float alpha0, /* (i) max correction-energy-fraction + (in [0,1]) */ + float period[], /* (i) pitch period array */ + float plocs[], /* (i) locations where period array + values valid */ + int periodl /* (i) dimension of period and plocs */ + ){ + float [] sseq = new float[(2*ilbc_constants.ENH_HL+1)*ilbc_constants.ENH_BLOCKL]; + + /* get said second sequence of segments */ + + getsseq(sseq,idata,idatal,centerStartPos,period, + plocs,periodl,ilbc_constants.ENH_HL); + + /* compute the smoothed output from said second sequence */ + + smath(odata, odata_idx, sseq,ilbc_constants.ENH_HL,alpha0); + + } + + /*----------------------------------------------------------------* + * cross correlation + *---------------------------------------------------------------*/ + + public float xCorrCoef( + float target[], /* (i) first array */ + int t_idx, + float regressor[], /* (i) second array */ + int r_idx, + int subl) /* (i) dimension arrays */ + { + int i; + float ftmp1, ftmp2; + + ftmp1 = 0.0f; + ftmp2 = 0.0f; + for (i=0; i<subl; i++) { + ftmp1 += target[t_idx + i] * regressor[r_idx + i]; + ftmp2 += regressor[r_idx + i] * regressor[r_idx + i]; + } + + if (ftmp1 > 0.0f) { + return (float)(ftmp1*ftmp1/ftmp2); + } + else { + return (float)0.0f; + } + } + + /*----------------------------------------------------------------* + * interface for enhancer + *---------------------------------------------------------------*/ + + int enhancerInterface( + float out[], /* (o) enhanced signal */ + float in[]) /* (i) unenhanced signal */ + { + // float *enh_buf, *enh_period; (definis en global pour la classe) + int iblock, isample; + int lag=0, ilag, i, ioffset; + float cc, maxcc; + float ftmp1, ftmp2; + // float *inPtr, *enh_bufPtr1, *enh_bufPtr2; + int inPtr, enh_bufPtr1, enh_bufPtr2; + float [] plc_pred = new float[ilbc_constants.ENH_BLOCKL]; + + float [] lpState = new float[6]; + float [] downsampled = new float[(ilbc_constants.ENH_NBLOCKS*ilbc_constants.ENH_BLOCKL+120)/2]; + int inLen=ilbc_constants.ENH_NBLOCKS*ilbc_constants.ENH_BLOCKL+120; + int start, plc_blockl, inlag; + + // enh_buf=iLBCdec_inst->enh_buf; + // enh_period=iLBCdec_inst->enh_period; + + System.arraycopy(enh_buf, this.ULP_inst.blockl, + enh_buf, 0, + ilbc_constants.ENH_BUFL-this.ULP_inst.blockl); +// memmove(enh_buf, &enh_buf[iLBCdec_inst->blockl], +// (ENH_BUFL-iLBCdec_inst->blockl)*sizeof(float)); + + + System.arraycopy(in, 0, enh_buf, ilbc_constants.ENH_BUFL-this.ULP_inst.blockl, + this.ULP_inst.blockl); +// memcpy(&enh_buf[ENH_BUFL-this.ULP_inst.blockl], in, +// this.ULP_inst.blockl*sizeof(float)); + + if (this.ULP_inst.mode==30) + plc_blockl=ilbc_constants.ENH_BLOCKL; + else + plc_blockl=40; + + /* when 20 ms frame, move processing one block */ + ioffset=0; + if (this.ULP_inst.mode==20) ioffset=1; + + i=3-ioffset; + System.arraycopy(enh_period, i, enh_period, 0, ilbc_constants.ENH_NBLOCKS_TOT-i); +// memmove(enh_period, &enh_period[i], +// (ENH_NBLOCKS_TOT-i)*sizeof(float)); + + /* Set state information to the 6 samples right before + the samples to be downsampled. */ + + System.arraycopy(enh_buf, (ilbc_constants.ENH_NBLOCKS_EXTRA+ioffset)*ilbc_constants.ENH_BLOCKL-126, + lpState, 0, 6); +// memcpy(lpState, +// enh_buf+(ENH_NBLOCKS_EXTRA+ioffset)*ENH_BLOCKL-126, +// 6*sizeof(float)); + + /* Down sample a factor 2 to save computations */ + + DownSample(enh_buf, + (ilbc_constants.ENH_NBLOCKS_EXTRA+ioffset)*ilbc_constants.ENH_BLOCKL-120, + ilbc_constants.lpFilt_coefsTbl, inLen-ioffset*ilbc_constants.ENH_BLOCKL, + lpState, downsampled); + + /* Estimate the pitch in the down sampled domain. */ + for (iblock = 0; iblock<ilbc_constants.ENH_NBLOCKS-ioffset; iblock++) { + + lag = 10; + maxcc = xCorrCoef(downsampled, 60+iblock * ilbc_constants.ENH_BLOCKL_HALF, + downsampled, 60+iblock * ilbc_constants.ENH_BLOCKL_HALF - lag, + ilbc_constants.ENH_BLOCKL_HALF); + for (ilag=11; ilag<60; ilag++) { + cc = xCorrCoef(downsampled, 60+iblock* ilbc_constants.ENH_BLOCKL_HALF, + downsampled, 60+iblock* ilbc_constants.ENH_BLOCKL_HALF - ilag, + ilbc_constants.ENH_BLOCKL_HALF); + + if (cc > maxcc) { + maxcc = cc; + lag = ilag; + } + } + + /* Store the estimated lag in the non-downsampled domain */ + enh_period[iblock+ilbc_constants.ENH_NBLOCKS_EXTRA+ioffset] = (float)lag*2; + + + } + + + /* PLC was performed on the previous packet */ + if (this.prev_enh_pl==1) { + + inlag=(int)enh_period[ilbc_constants.ENH_NBLOCKS_EXTRA+ioffset]; + + lag = inlag-1; + maxcc = xCorrCoef(in, 0, in, lag, plc_blockl); + for (ilag=inlag; ilag<=inlag+1; ilag++) { + cc = xCorrCoef(in, 0, in, ilag, plc_blockl); + if (cc > maxcc) { + maxcc = cc; + lag = ilag; + } + } + + enh_period[ilbc_constants.ENH_NBLOCKS_EXTRA+ioffset-1]=(float)lag; + + /* compute new concealed residual for the old lookahead, + mix the forward PLC with a backward PLC from + the new frame */ + + // inPtr=&in[lag-1]; + inPtr = lag - 1; + + // enh_bufPtr1=&plc_pred[plc_blockl-1]; + enh_bufPtr1 = plc_blockl - 1; + + if (lag>plc_blockl) { + start=plc_blockl; + } else { + start=lag; + } + + for (isample = start; isample>0; isample--) { + // *enh_bufPtr1-- = *inPtr--; + plc_pred[enh_bufPtr1] = in[inPtr]; + enh_bufPtr1--; + inPtr--; + } + + // enh_bufPtr2=&enh_buf[ENH_BUFL-1-this.ULP_inst.blockl]; + enh_bufPtr2 = ilbc_constants.ENH_BUFL - 1 - this.ULP_inst.blockl; + for (isample = (plc_blockl-1-lag); isample>=0; isample--) { + // *enh_bufPtr1-- = *enh_bufPtr2--; + plc_pred[enh_bufPtr1] = enh_buf[enh_bufPtr2]; + enh_bufPtr1--; + enh_bufPtr2--; + } + + /* limit energy change */ + ftmp2=0.0f; + ftmp1=0.0f; + for (i=0;i<plc_blockl;i++) { + ftmp2+=enh_buf[ilbc_constants.ENH_BUFL-1-this.ULP_inst.blockl-i]* + enh_buf[ilbc_constants.ENH_BUFL-1-this.ULP_inst.blockl-i]; + ftmp1+=plc_pred[i]*plc_pred[i]; + } + ftmp1=(float)(float)Math.sqrt(ftmp1/(float)plc_blockl); + ftmp2=(float)(float)Math.sqrt(ftmp2/(float)plc_blockl); + if (ftmp1>(float)2.0f*ftmp2 && ftmp1>0.0) { + for (i=0;i<plc_blockl-10;i++) { + plc_pred[i]*=(float)2.0f*ftmp2/ftmp1; + } + for (i=plc_blockl-10;i<plc_blockl;i++) { + plc_pred[i]*=(float)(i-plc_blockl+10)* + ((float)1.0f-(float)2.0*ftmp2/ftmp1)/(float)(10)+ + (float)2.0f*ftmp2/ftmp1; + } + } + + enh_bufPtr1=ilbc_constants.ENH_BUFL-1-this.ULP_inst.blockl; +// enh_bufPtr1=&enh_buf[ilbc_constants.ENH_BUFL-1-this.ULP_inst.blockl]; + for (i=0; i<plc_blockl; i++) { + ftmp1 = (float) (i+1) / (float) (plc_blockl+1); + enh_buf[enh_bufPtr1] *= ftmp1; +// *enh_bufPtr1 *= ftmp1; + enh_buf[enh_bufPtr1] += ((float)1.0f-ftmp1)* + plc_pred[plc_blockl-1-i]; +// *enh_bufPtr1 += ((float)1.0f-ftmp1)* +// plc_pred[plc_blockl-1-i]; + enh_bufPtr1--; + } + } + + if (this.ULP_inst.mode==20) { + /* Enhancer with 40 samples delay */ + for (iblock = 0; iblock<2; iblock++) { + enhancer(out, iblock*ilbc_constants.ENH_BLOCKL, enh_buf, + ilbc_constants.ENH_BUFL, (5+iblock)*ilbc_constants.ENH_BLOCKL+40, + ilbc_constants.ENH_ALPHA0, enh_period, ilbc_constants.enh_plocsTbl, + ilbc_constants.ENH_NBLOCKS_TOT); + } + } else if (this.ULP_inst.mode==30) { + /* Enhancer with 80 samples delay */ + for (iblock = 0; iblock<3; iblock++) { + enhancer(out, iblock*ilbc_constants.ENH_BLOCKL, enh_buf, + ilbc_constants.ENH_BUFL, (4+iblock)*ilbc_constants.ENH_BLOCKL, + ilbc_constants.ENH_ALPHA0, enh_period, ilbc_constants.enh_plocsTbl, + ilbc_constants.ENH_NBLOCKS_TOT); + } + } + + return (lag*2); + } + + /*----------------------------------------------------------------* + * Packet loss concealment routine. Conceals a residual signal + * and LP parameters. If no packet loss, update state. + *---------------------------------------------------------------*/ + + /*----------------------------------------------------------------* + * Compute cross correlation and pitch gain for pitch prediction + * of last subframe at given lag. + *---------------------------------------------------------------*/ + + public void compCorr( + float cc[], /* (o) cross correlation coefficient */ + float gc[], /* (o) gain */ + float pm[], + float buffer[], /* (i) signal buffer */ + int lag, /* (i) pitch lag */ + int bLen, /* (i) length of buffer */ + int sRange) /* (i) correlation search length */ + { + int i; + float ftmp1, ftmp2, ftmp3; + + /* Guard against getting outside buffer */ + if ((bLen - sRange - lag) < 0) { + sRange = bLen - lag; + } + + ftmp1 = 0.0f; + ftmp2 = 0.0f; + ftmp3 = 0.0f; + + for (i=0; i<sRange; i++) { + ftmp1 += buffer[bLen-sRange+i] * + buffer[bLen-sRange+i-lag]; + ftmp2 += buffer[bLen-sRange+i-lag] * + buffer[bLen-sRange+i-lag]; + ftmp3 += buffer[bLen-sRange+i] * + buffer[bLen-sRange+i]; + } + + if (ftmp2 > 0.0f) { + cc[0] = ftmp1*ftmp1/ftmp2; + gc[0] = (float)(float)Math.abs(ftmp1 / ftmp2); + pm[0] = (float)(float)Math.abs(ftmp1) / + ((float)(float)Math.sqrt(ftmp2)*(float)Math.sqrt(ftmp3)); + } + else { + cc[0] = 0.0f; + gc[0] = 0.0f; + pm[0] = 0.0f; + } + } + + public void doThePLC( + float PLCresidual[], /* (o) concealed residual */ + float PLClpc[], /* (o) concealed LP parameters */ + int PLI, /* (i) packet loss indicator + 0 - no PL, 1 = PL */ + float decresidual[], /* (i) decoded residual */ + float lpc[], /* (i) decoded LPC (only used for no PL) */ + int lpc_idx, + int inlag) /* (i) pitch lag */ + { + int lag = 20, randlag = 0; + float gain = 0.0f, maxcc = 0.0f; + float use_gain = 0.0f; + float gain_comp = 0.0f, maxcc_comp = 0.0f, per = 0.0f, max_per = 0.0f; + int i, pick, use_lag; + float ftmp, randvec[], pitchfact, energy; + float [] a_gain, a_comp, a_per; + + randvec = new float [ilbc_constants.BLOCKL_MAX]; + + a_gain = new float[1]; + a_comp = new float[1]; + a_per = new float[1]; + + /* Packet Loss */ + + if (PLI == 1) { + + this.consPLICount += 1; + + /* if previous frame not lost, + determine pitch pred. gain */ + + if (this.prevPLI != 1) { + + /* Search around the previous lag to find the + best pitch period */ + + lag=inlag-3; + + a_comp[0] = maxcc; + a_gain[0] = gain; + a_per[0] = max_per; + compCorr(a_comp, a_gain, a_per, + this.prevResidual, + lag, this.ULP_inst.blockl, 60); + maxcc = a_comp[0]; + gain = a_gain[0]; + max_per = a_per[0]; + + for (i=inlag-2;i<=inlag+3;i++) { + + a_comp[0] = maxcc_comp; + a_gain[0] = gain_comp; + a_per[0] = per; + compCorr(a_comp, a_gain, a_per, + this.prevResidual, + i, this.ULP_inst.blockl, 60); + maxcc_comp = a_comp[0]; + gain_comp = a_gain[0]; + per = a_per[0]; + + if (maxcc_comp>maxcc) { + maxcc=maxcc_comp; + gain=gain_comp; + lag=i; + max_per=per; + } + } + } + + /* previous frame lost, use recorded lag and periodicity */ + + else { + lag=this.prevLag; + max_per=this.per; + } + + /* downscaling */ + + use_gain=1.0f; + if (this.consPLICount*this.ULP_inst.blockl>320) + use_gain=(float)0.9; + else if (this.consPLICount*this.ULP_inst.blockl>2*320) + use_gain=(float)0.7; + else if (this.consPLICount*this.ULP_inst.blockl>3*320) + use_gain=(float)0.5; + else if (this.consPLICount*this.ULP_inst.blockl>4*320) + use_gain=(float)0.0f; + + /* mix noise and pitch repeatition */ + ftmp=(float)(float)Math.sqrt(max_per); + if (ftmp>(float)0.7) + pitchfact=(float)1.0f; + else if (ftmp>(float)0.4) + pitchfact=(ftmp-(float)0.4)/((float)0.7-(float)0.4); + else + pitchfact=0.0f; + + + /* avoid repetition of same pitch cycle */ + use_lag=lag; + if (lag<80) { + use_lag=2*lag; + } + + /* compute concealed residual */ + energy = 0.0f; + for (i=0; i<this.ULP_inst.blockl; i++) { + + /* noise component */ + + this.seed = (this.seed * 69069 + 1) & (0x80000000 - 1); + randlag = 50 + (int) (this.seed % 70); + pick = i - randlag; + + if (pick < 0) { + randvec[i] = this.prevResidual[this.ULP_inst.blockl+pick]; + } else { + randvec[i] = randvec[pick]; + } + + /* pitch repeatition component */ + pick = i - use_lag; + + if (pick < 0) { + PLCresidual[i] = this.prevResidual[this.ULP_inst.blockl+pick]; + } else { + PLCresidual[i] = PLCresidual[pick]; + } + + /* mix random and periodicity component */ + + if (i<80) + PLCresidual[i] = use_gain*(pitchfact * + PLCresidual[i] + + ((float)1.0f - pitchfact) * randvec[i]); + else if (i<160) + PLCresidual[i] = (float)0.95*use_gain*(pitchfact * + PLCresidual[i] + + ((float)1.0f - pitchfact) * randvec[i]); + else + PLCresidual[i] = (float)0.9*use_gain*(pitchfact * + PLCresidual[i] + + ((float)1.0f - pitchfact) * randvec[i]); + + energy += PLCresidual[i] * PLCresidual[i]; + } + + /* less than 30 dB, use only noise */ + + if ((float)Math.sqrt(energy/(float)this.ULP_inst.blockl) < 30.0f) { + gain=0.0f; + for (i=0; i<this.ULP_inst.blockl; i++) { + PLCresidual[i] = randvec[i]; + } + } + + /* use old LPC */ + + // memcpy(PLClpc,this.prevLpc, (LPC_FILTERORDER+1)*sizeof(float)); + System.arraycopy(this.prevLpc, 0, PLClpc, 0, ilbc_constants.LPC_FILTERORDER + 1); + + } + + /* no packet loss, copy input */ + + else { + // memcpy(PLCresidual, decresidual,this.ULP_inst.blockl*sizeof(float)); + System.arraycopy(decresidual, 0, PLCresidual, 0, this.ULP_inst.blockl); + // memcpy(PLClpc, lpc, (LPC_FILTERORDER+1)*sizeof(float)); + System.arraycopy(lpc, lpc_idx, PLClpc, 0, ilbc_constants.LPC_FILTERORDER + 1); + this.consPLICount = 0; + } + + /* update state */ + + if (PLI != 0) { + this.prevLag = lag; + this.per=max_per; + } + + this.prevPLI = PLI; + // memcpy(this.prevLpc, PLClpc, (LPC_FILTERORDER+1)*sizeof(float)); + System.arraycopy(PLClpc, 0, this.prevLpc, 0, ilbc_constants.LPC_FILTERORDER + 1); + // memcpy(this.prevResidual, PLCresidual, this.ULP_inst.blockl*sizeof(float)); + System.arraycopy(PLCresidual, 0, this.prevResidual, 0, this.ULP_inst.blockl); + } + +// public int decode(short decoded_data[], short encoded_data[], int mode) +// { +// return this.ULP_inst.blockl; +// } + + public short decode( /* (o) Number of decoded samples */ + short decoded_data[], /* (o) Decoded signal block*/ + short encoded_data[], /* (i) Encoded bytes */ + short mode) /* (i) 0=PL, 1=Normal */ + { + int k; + float decblock [] = new float[ilbc_constants.BLOCKL_MAX]; + float dtmp; + // char en_data[] = new char [this.ULP_inst.no_of_bytes]; + bitstream en_data = new bitstream(this.ULP_inst.no_of_bytes); + + /* check if mode is valid */ + + if ( (mode < 0) || (mode > 1)) { + System.out.println("\nERROR - Wrong mode - 0, 1 allowed\n"); + } + + /* do actual decoding of block */ + for (k = 0; k < encoded_data.length; k++) { + en_data.buffer[2*k+1] = (char) (encoded_data[k] & 0xff); + en_data.buffer[2*k] = (char) ((encoded_data[k] >> 8) & 0xff); +// System.out.println("on decode " + (en_data.buffer[2*k]+0) + " et " + (en_data.buffer[2*k+1]+0)); + } + + iLBC_decode(decblock, en_data, mode); + + /* convert to short */ + for (k = 0; k < this.ULP_inst.blockl; k++) { + dtmp=decblock[k]; +// System.out.println("on a eu : " + dtmp); + + if (dtmp < ilbc_constants.MIN_SAMPLE) + dtmp = ilbc_constants.MIN_SAMPLE; + else if (dtmp > ilbc_constants.MAX_SAMPLE) + dtmp = ilbc_constants.MAX_SAMPLE; + decoded_data[k] = (short) dtmp; + } + + return ((short) this.ULP_inst.blockl); + } + + /*----------------------------------------------------------------* + * frame residual decoder function (subrutine to iLBC_decode) + *---------------------------------------------------------------*/ + + public void Decode( + 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 = new float[ilbc_constants.BLOCKL_MAX]; + float [] mem = new float[ilbc_constants.CB_MEML]; + int k, meml_gotten, Nfor, Nback, i; + int diff, start_pos; + int subcount, subframe; + + diff = ilbc_constants.STATE_LEN - this.ULP_inst.state_short_len; + + if (state_first == 1) { + start_pos = (start-1) * ilbc_constants.SUBL; + } else { + start_pos = (start-1) * ilbc_constants.SUBL + diff; + } + + /* decode scalar part of start state */ + + ilbc_common.StateConstructW(idxForMax, idxVec, + syntdenum, (start-1)*(ilbc_constants.LPC_FILTERORDER+1), + decresidual, start_pos, this.ULP_inst.state_short_len); + + + if (state_first != 0) { /* put adaptive part in the end */ + + /* setup memory */ + + for (int li = 0; li < (ilbc_constants.CB_MEML-this.ULP_inst.state_short_len); li++) + mem[li] = 0.0f; +// memset(mem, 0, +// (CB_MEML-this.ULP_inst.state_short_len)*sizeof(float)); + System.arraycopy(decresidual, start_pos, + mem, ilbc_constants.CB_MEML - this.ULP_inst.state_short_len, + this.ULP_inst.state_short_len); +// memcpy(mem+CB_MEML-this.ULP_inst.state_short_len, +// decresidual+start_pos, +// this.ULP_inst.state_short_len*sizeof(float)); + + /* construct decoded vector */ + + ilbc_common.iCBConstruct(decresidual, start_pos+this.ULP_inst.state_short_len, + extra_cb_index, 0, extra_gain_index, 0, + mem, ilbc_constants.CB_MEML - ilbc_constants.stMemLTbl, + ilbc_constants.stMemLTbl, diff, ilbc_constants.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)*ilbc_constants.SUBL - 1 - + (k+this.ULP_inst.state_short_len)]; + } + + /* setup memory */ + + meml_gotten = this.ULP_inst.state_short_len; + for (k=0; k<meml_gotten; k++){ + mem[ilbc_constants.CB_MEML-1-k] = decresidual[start_pos + k]; + } + for (int li = 0; li < ilbc_constants.CB_MEML - k; li++) + mem[li] = 0.0f; + // memset(mem, 0, (CB_MEML-k)*sizeof(float)); + + /* construct decoded vector */ + + ilbc_common.iCBConstruct(reverseDecresidual, 0, extra_cb_index, 0, + extra_gain_index, 0, + mem, ilbc_constants.CB_MEML - ilbc_constants.stMemLTbl, + ilbc_constants.stMemLTbl, diff, ilbc_constants.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 = this.ULP_inst.nsub-start-1; + + if ( Nfor > 0 ){ + + /* setup memory */ + + for (int li = 0; li < ilbc_constants.CB_MEML - ilbc_constants.STATE_LEN; li++) + mem[li] = 0.0f; + // memset(mem, 0, (CB_MEML-STATE_LEN)*sizeof(float)); + System.arraycopy(decresidual, (start - 1) * ilbc_constants.SUBL, + mem, ilbc_constants.CB_MEML - ilbc_constants.STATE_LEN, + ilbc_constants.STATE_LEN); + // 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 */ + + ilbc_common.iCBConstruct(decresidual, (start+1+subframe)*ilbc_constants.SUBL, + cb_index, subcount*ilbc_constants.CB_NSTAGES, + gain_index, subcount*ilbc_constants.CB_NSTAGES, + mem, ilbc_constants.CB_MEML-ilbc_constants.memLfTbl[subcount], + ilbc_constants.memLfTbl[subcount], ilbc_constants.SUBL, + ilbc_constants.CB_NSTAGES); + + /* update memory */ + + System.arraycopy(mem, ilbc_constants.SUBL, + mem, 0, + ilbc_constants.CB_MEML - ilbc_constants.SUBL); + // memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float)); + System.arraycopy(decresidual, (start + 1 + subframe) * ilbc_constants.SUBL, + mem, ilbc_constants.CB_MEML - ilbc_constants.SUBL, + ilbc_constants.SUBL); + // 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 = ilbc_constants.SUBL*(this.ULP_inst.nsub+1-start); + + if ( meml_gotten > ilbc_constants.CB_MEML ) { + meml_gotten = ilbc_constants.CB_MEML; + } + for (k=0; k<meml_gotten; k++) { + mem[ilbc_constants.CB_MEML-1-k] = decresidual[(start-1)*ilbc_constants.SUBL + k]; + } + for (int li = 0; li < (ilbc_constants.CB_MEML - k); li++) + mem[li] = 0.0f; +// memset(mem, 0, (ilbc_constants.CB_MEML-k)*sizeof(float)); + + /* loop over subframes to decode */ + + for (subframe=0; subframe<Nback; subframe++) { + + /* construct decoded vector */ + + ilbc_common.iCBConstruct(reverseDecresidual, subframe * ilbc_constants.SUBL, + cb_index, subcount * ilbc_constants.CB_NSTAGES, + gain_index, subcount * ilbc_constants.CB_NSTAGES, + mem, ilbc_constants.CB_MEML - ilbc_constants.memLfTbl[subcount], + ilbc_constants.memLfTbl[subcount], ilbc_constants.SUBL, + ilbc_constants.CB_NSTAGES); + + /* update memory */ + + System.arraycopy(mem, ilbc_constants.SUBL, + mem, 0, + ilbc_constants.CB_MEML - ilbc_constants.SUBL); +// memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float)); + System.arraycopy(reverseDecresidual, subframe * ilbc_constants.SUBL, + mem, ilbc_constants.CB_MEML - ilbc_constants.SUBL, + ilbc_constants.SUBL); +// memcpy(mem+CB_MEML-SUBL, +// &reverseDecresidual[subframe*SUBL], +// SUBL*sizeof(float)); + + subcount++; + } + + /* get decoded residual from reversed vector */ + + for (i=0; i < ilbc_constants.SUBL*Nback; i++) + decresidual[ilbc_constants.SUBL*Nback - i - 1] = + reverseDecresidual[i]; + } + } + + + /*----------------------------------------------------------------* + * main decoder function + *---------------------------------------------------------------*/ + + void iLBC_decode( + float decblock[], /* (o) decoded signal block */ + bitstream bytes, /* (i) encoded signal bits */ + int mode ) /* (i) 0: bad packet, PLC, + 1: normal */ + { + float [] data = new float[ilbc_constants.BLOCKL_MAX]; + float [] lsfdeq = new float[ilbc_constants.LPC_FILTERORDER * ilbc_constants.LPC_N_MAX]; + float [] PLCresidual = new float[ilbc_constants.BLOCKL_MAX]; + float [] PLClpc = new float[ilbc_constants.LPC_FILTERORDER + 1]; + float [] zeros = new float[ilbc_constants.BLOCKL_MAX]; + float [] one = new float[ilbc_constants.LPC_FILTERORDER + 1]; + int k, i, start, idxForMax, pos, lastpart, ulp; + int lag, ilag; + float cc, maxcc; + int [] idxVec = new int[ilbc_constants.STATE_LEN]; + int check; + int [] gain_index = new int[ilbc_constants.NASUB_MAX * ilbc_constants.CB_NSTAGES]; + int [] extra_gain_index = new int[ilbc_constants.CB_NSTAGES]; + int [] cb_index = new int[ilbc_constants.CB_NSTAGES * ilbc_constants.NASUB_MAX]; + int [] extra_cb_index = new int[ilbc_constants.CB_NSTAGES]; + int [] lsf_i = new int[ilbc_constants.LSF_NSPLIT * ilbc_constants.LPC_N_MAX]; + int state_first; + int last_bit; + // unsigned char *pbytes; + float [] weightdenum = new float[(ilbc_constants.LPC_FILTERORDER + 1) * + ilbc_constants.NSUB_MAX]; + int order_plus_one; + float [] syntdenum = new float[ilbc_constants.NSUB_MAX * (ilbc_constants.LPC_FILTERORDER + 1)]; + float [] decresidual = new float[ilbc_constants.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<ilbc_constants.LSF_NSPLIT * ilbc_constants.LPC_N_MAX; k++) { + lsf_i[k]=0; + } + start = 0; + state_first = 0; + idxForMax = 0; + for (k = 0; k < this.ULP_inst.state_short_len; k++) { + idxVec[k]=0; + } + for (k=0; k<ilbc_constants.CB_NSTAGES; k++) { + extra_cb_index[k]=0; + } + for (k=0; k<ilbc_constants.CB_NSTAGES; k++) { + extra_gain_index[k]=0; + } + for (i=0; i<this.ULP_inst.nasub; i++) { + for (k=0; k<ilbc_constants.CB_NSTAGES; k++) { + cb_index[i*ilbc_constants.CB_NSTAGES+k]=0; + } + } + for (i=0; i<this.ULP_inst.nasub; i++) { + for (k=0; k<ilbc_constants.CB_NSTAGES; k++) { + gain_index[i*ilbc_constants.CB_NSTAGES+k]=0; + } + } + + /* loop over ULP classes */ + + for (ulp=0; ulp<3; ulp++) { + + /* LSF */ + for (k=0; k<ilbc_constants.LSF_NSPLIT*this.ULP_inst.lpc_n; k++){ + lastpart = bytes.unpack(this.ULP_inst.lsf_bits[k][ulp]); +// unpack( &pbytes, &lastpart, +// this.ULP_inst.lsf_bits[k][ulp], &pos); + lsf_i[k] = bytes.packcombine(lsf_i[k], lastpart, + this.ULP_inst.lsf_bits[k][ulp]); + // System.out.println("lsf_i["+k+"] = " + lsf_i[k]); +// packcombine(&lsf_i[k], lastpart, +// this.ULP_inst.lsf_bits[k][ulp]); + } + + /* Start block info */ + + lastpart = bytes.unpack(this.ULP_inst.start_bits[ulp]); +// unpack( &pbytes, &lastpart, +// this.ULP_inst.start_bits[ulp], &pos); + start = bytes.packcombine(start, lastpart, + this.ULP_inst.start_bits[ulp]); + // System.out.println("start = " + start); +// packcombine(&start, lastpart, +// this.ULP_inst.start_bits[ulp]); + + lastpart = bytes.unpack(this.ULP_inst.startfirst_bits[ulp]); +// unpack( &pbytes, &lastpart, +// this.ULP_inst.startfirst_bits[ulp], &pos); + state_first = bytes.packcombine(state_first, lastpart, + this.ULP_inst.startfirst_bits[ulp]); + // System.out.println("state_first = " + state_first); +// packcombine(&state_first, lastpart, +// this.ULP_inst.startfirst_bits[ulp]); + + lastpart = bytes.unpack(this.ULP_inst.scale_bits[ulp]); +// unpack( &pbytes, &lastpart, +// this.ULP_inst.scale_bits[ulp], &pos); + idxForMax = bytes.packcombine(idxForMax, lastpart, + this.ULP_inst.scale_bits[ulp]); + // System.out.println("idxForMax = " + idxForMax); +// packcombine(&idxForMax, lastpart, +// this.ULP_inst.scale_bits[ulp]); + + for (k=0; k<this.ULP_inst.state_short_len; k++) { + lastpart = bytes.unpack(this.ULP_inst.state_bits[ulp]); +// unpack( &pbytes, &lastpart, +// this.ULP_inst.state_bits[ulp], &pos); + idxVec[k] = bytes.packcombine(idxVec[k], lastpart, + this.ULP_inst.state_bits[ulp]); + // System.out.println("idxVec["+k+"] = " + idxVec[k]); +// packcombine(idxVec+k, lastpart, +// this.ULP_inst.state_bits[ulp]); + } + + /* 23/22 (20ms/30ms) sample block */ + + for (k=0; k<ilbc_constants.CB_NSTAGES; k++) { + lastpart = bytes.unpack(this.ULP_inst.extra_cb_index[k][ulp]); +// unpack( &pbytes, &lastpart, +// this.ULP_inst.extra_cb_index[k][ulp], +// &pos); + extra_cb_index[k] = bytes.packcombine(extra_cb_index[k], lastpart, + this.ULP_inst.extra_cb_index[k][ulp]); + // System.out.println("extra_cb_index["+k+"] = " + extra_cb_index[k]); +// packcombine(extra_cb_index+k, lastpart, +// this.ULP_inst.extra_cb_index[k][ulp]); + } + for (k=0; k<ilbc_constants.CB_NSTAGES; k++) { + lastpart = bytes.unpack(this.ULP_inst.extra_cb_gain[k][ulp]); +// unpack( &pbytes, &lastpart, +// this.ULP_inst.extra_cb_gain[k][ulp], +// &pos); + extra_gain_index[k] = bytes.packcombine(extra_gain_index[k], lastpart, + this.ULP_inst.extra_cb_gain[k][ulp]); + // System.out.println("extra_gain_index["+k+"] = " + extra_gain_index[k]); +// packcombine(extra_gain_index+k, lastpart, +// this.ULP_inst.extra_cb_gain[k][ulp]); + } + + /* The two/four (20ms/30ms) 40 sample sub-blocks */ + + for (i=0; i<this.ULP_inst.nasub; i++) { + for (k=0; k<ilbc_constants.CB_NSTAGES; k++) { + lastpart = bytes.unpack(this.ULP_inst.cb_index[i][k][ulp]); +// unpack( &pbytes, &lastpart, +// this.ULP_inst.cb_index[i][k][ulp], +// &pos); + cb_index[i * ilbc_constants.CB_NSTAGES + k] = + bytes.packcombine(cb_index[i*ilbc_constants.CB_NSTAGES+k], lastpart, + this.ULP_inst.cb_index[i][k][ulp]); + // System.out.println("cb_index["+(i*ilbc_constants.CB_NSTAGES+k)+"] = " + cb_index[(i*ilbc_constants.CB_NSTAGES+k)]); +// packcombine(cb_index+i*CB_NSTAGES+k, lastpart, +// this.ULP_inst.cb_index[i][k][ulp]); + } + } + + for (i=0; i<this.ULP_inst.nasub; i++) { + for (k=0; k<ilbc_constants.CB_NSTAGES; k++) { + lastpart = bytes.unpack(this.ULP_inst.cb_gain[i][k][ulp]); + gain_index[i * ilbc_constants.CB_NSTAGES+k] = + bytes.packcombine(gain_index[i*ilbc_constants.CB_NSTAGES+k], lastpart, + this.ULP_inst.cb_gain[i][k][ulp]); + // System.out.println("gain_index["+(i*ilbc_constants.CB_NSTAGES+k)+"] = " + gain_index[(i*ilbc_constants.CB_NSTAGES+k)]); + } + } + } + /* Extract last bit. If it is 1 this indicates an + empty/lost frame */ + last_bit = bytes.unpack(1); + // System.out.println("last_bit = " + last_bit); + + /* Check for bit errors or empty/lost frames */ + if (start < 1) + mode = 0; + if (this.ULP_inst.mode==20 && start>3) + mode = 0; + if (this.ULP_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); + +// for (int li = 0; li < cb_index.length; li++) +// System.out.println("cb_index["+li+"] = " + cb_index[li]); + + /* decode the lsf */ + + SimplelsfDEQ(lsfdeq, lsf_i, this.ULP_inst.lpc_n); +// for (int li = 0; li < lsfdeq.length; li++) +// System.out.println("lsfdeq["+li+"] = " + lsfdeq[li]); + check=ilbc_common.LSF_check(lsfdeq, ilbc_constants.LPC_FILTERORDER, + this.ULP_inst.lpc_n); +// System.out.println("check returns " + check); + DecoderInterpolateLSF(syntdenum, weightdenum, + lsfdeq, ilbc_constants.LPC_FILTERORDER); +// for (int li = 0; li < syntdenum.length; li++) +// System.out.println("syntdenum[" + li + "] = " + syntdenum[li]); +// for (int li = 0; li < weightdenum.length; li++) +// System.out.println("weightdenum[" + li + "] = " + weightdenum[li]); + + Decode(decresidual, start, idxForMax, + idxVec, syntdenum, cb_index, gain_index, + extra_cb_index, extra_gain_index, + state_first); + +// for (int li = 0; li < decresidual.length; li++) +// System.out.println("decresidual[" + li + "] = " + decresidual[li]); + + /* preparing the plc for a future loss! */ + + doThePLC(PLCresidual, PLClpc, 0, decresidual, + syntdenum, + (ilbc_constants.LPC_FILTERORDER + 1)*(this.ULP_inst.nsub - 1), + last_lag); + + System.arraycopy(PLCresidual, 0, decresidual, 0, this.ULP_inst.blockl); +// for (int li = 0; li < decresidual.length; li++) +// System.out.println("decresidual[" + li + "] = " + decresidual[li]); +// memcpy(decresidual, PLCresidual, +// this.ULP_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 */ + + for (int li = 0; li < ilbc_constants.BLOCKL_MAX; li++) + zeros[li] = 0.0f; + // memset(zeros, 0, BLOCKL_MAX*sizeof(float)); + + one[0] = 1; + for (int li = 0; li < ilbc_constants.LPC_FILTERORDER; li++) + one[li+1] = 0.0f; + // memset(one+1, 0, LPC_FILTERORDER*sizeof(float)); + + start=0; + + doThePLC(PLCresidual, PLClpc, 1, zeros, one, 0, + last_lag); + System.arraycopy(PLCresidual, 0, decresidual, 0, this.ULP_inst.blockl); +// memcpy(decresidual, PLCresidual, +// this.ULP_inst.blockl*sizeof(float)); + + order_plus_one = ilbc_constants.LPC_FILTERORDER + 1; + for (i = 0; i < this.ULP_inst.nsub; i++) { + System.arraycopy(PLClpc, 0, syntdenum, (i * order_plus_one), order_plus_one); +// memcpy(syntdenum+(i*order_plus_one), PLClpc, +// order_plus_one*sizeof(float)); + } + } + + if (this.use_enhancer == 1) { + + /* post filtering */ + + this.last_lag = enhancerInterface(data, decresidual); + +// System.out.println("last_lag : " + this.last_lag); + +// for (int li = 0; li < data.length; li++) +// System.out.println("data["+li+"] = " + data[li]); + + // for (li = 0; li < + + /* synthesis filtering */ + + if (this.ULP_inst.mode == 20) { + /* Enhancer has 40 samples delay */ + i = 0; +// System.out.println("run 1"); + syntFilter(data,i * ilbc_constants.SUBL, + this.old_syntdenum, + (i+this.ULP_inst.nsub-1)*(ilbc_constants.LPC_FILTERORDER+1), + ilbc_constants.SUBL, this.syntMem); +// System.out.println("runs 2"); + for (i=1; i < this.ULP_inst.nsub; i++) { +// System.out.println("pass " + i); + syntFilter(data, i * ilbc_constants.SUBL, + syntdenum, (i-1)*(ilbc_constants.LPC_FILTERORDER+1), + ilbc_constants.SUBL, this.syntMem); +// System.out.println("pass " + i + " ends"); + } +// for (int li = 0; li < data.length; li++) +// System.out.println("psdata["+li+"] = " + data[li]); + + } else if (this.ULP_inst.mode == 30) { + /* Enhancer has 80 samples delay */ +// System.out.println("runs 3"); + for (i = 0; i < 2; i++) { + syntFilter(data, i * ilbc_constants.SUBL, + this.old_syntdenum, + (i+this.ULP_inst.nsub-2)*(ilbc_constants.LPC_FILTERORDER+1), + ilbc_constants.SUBL, this.syntMem); + } + for (i=2; i < this.ULP_inst.nsub; i++) { +// System.out.println("runs 4"); + syntFilter(data, i * ilbc_constants.SUBL, + syntdenum, (i-2)*(ilbc_constants.LPC_FILTERORDER+1), + ilbc_constants.SUBL, this.syntMem); + } + } + + } else { + + /* Find last lag */ + lag = 20; + maxcc = xCorrCoef(decresidual, + ilbc_constants.BLOCKL_MAX - ilbc_constants.ENH_BLOCKL, + decresidual, + ilbc_constants.BLOCKL_MAX - ilbc_constants.ENH_BLOCKL-lag, + ilbc_constants.ENH_BLOCKL); + + for (ilag = 21; ilag < 120; ilag++) { + cc = xCorrCoef(decresidual, + ilbc_constants.BLOCKL_MAX - ilbc_constants.ENH_BLOCKL, + decresidual, + ilbc_constants.BLOCKL_MAX - ilbc_constants.ENH_BLOCKL - ilag, + ilbc_constants.ENH_BLOCKL); + + if (cc > maxcc) { + maxcc = cc; + lag = ilag; + } + } + this.last_lag = lag; + + /* copy data and run synthesis filter */ + + System.arraycopy(decresidual, 0, data, 0, this.ULP_inst.blockl); +// memcpy(data, decresidual, +// this.ULP_inst.blockl*sizeof(float)); +// System.out.println("runs 5"); + for (i=0; i < this.ULP_inst.nsub; i++) { + syntFilter(data, i * ilbc_constants.SUBL, + syntdenum, i * (ilbc_constants.LPC_FILTERORDER + 1), + ilbc_constants.SUBL, this.syntMem); + } + + } + + /* high pass filtering on output if desired, otherwise + copy to out */ + + hpOutput(data, this.ULP_inst.blockl, decblock, this.hpomem); + + /* memcpy(decblock,data,iLBCdec_inst->blockl*sizeof(float));*/ + + System.arraycopy(syntdenum, 0, this.old_syntdenum, 0, + this.ULP_inst.nsub * (ilbc_constants.LPC_FILTERORDER+1)); +// memcpy(this.old_syntdenum, syntdenum, +// this.ULP_inst.nsub*(LPC_FILTERORDER+1)*sizeof(float)); + + this.prev_enh_pl=0; + + if (mode==0) { /* PLC was used */ + this.prev_enh_pl=1; + } + } + + + public ilbc_decoder(int init_mode, int init_enhancer) + { + ULP_inst = new ilbc_ulp(init_mode); + /* properties to initialize : */ + syntMem = new float[ilbc_constants.LPC_FILTERORDER]; + prevLpc = new float[ilbc_constants.LPC_FILTERORDER+1]; + prevResidual = new float[ilbc_constants.NSUB_MAX*ilbc_constants.SUBL]; + old_syntdenum = new float[(ilbc_constants.LPC_FILTERORDER + 1) * ilbc_constants.NSUB_MAX]; + hpomem = new float[4]; + enh_buf = new float[ilbc_constants.ENH_BUFL]; + enh_period = new float[ilbc_constants.ENH_NBLOCKS_TOT]; + lsfdeqold = new float[ilbc_constants.LPC_FILTERORDER]; + + for (int li = 0; li < syntMem.length; li++) + syntMem[li] = 0.0f; + + System.arraycopy(ilbc_constants.lsfmeanTbl, 0, lsfdeqold, 0, + ilbc_constants.LPC_FILTERORDER); +// for (int li = 0; li < lsfdeqold.length; li++) +// lsfdeqold[li] = 0.0f; + + for (int li = 0; li < old_syntdenum.length; li++) + old_syntdenum[li] = 0.0f; + + for (int li = 0; li < ilbc_constants.NSUB_MAX; li++) + old_syntdenum[li * (ilbc_constants.LPC_FILTERORDER + 1)] = 1.0f; + + last_lag = 20; + prevLag = 120; + per = 0.0f; + consPLICount = 0; + prevPLI = 0; + prevLpc[0] = 1.0f; + for (int li = 1; li < prevLpc.length; li++) + prevLpc[li] = 0.0f; + for (int li = 0; li < prevResidual.length; li++) + prevResidual[li] = 0.0f; + seed = 777; + + for (int li = 0; li < hpomem.length; li++) + hpomem[li] = 0.0f; + + use_enhancer = init_enhancer; + for (int li = 0; li < enh_buf.length; li++) + enh_buf[li] = 0.0f; + for (int li = 0; li < ilbc_constants.ENH_NBLOCKS_TOT; li++) + enh_period[li] = 40.0f; + prev_enh_pl = 0; + } +} + diff --git a/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/ilbc_encoder.java b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/ilbc_encoder.java new file mode 100644 index 0000000..fdd2f1f --- /dev/null +++ b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/ilbc_encoder.java @@ -0,0 +1,2344 @@ +/* + * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client. + * + * Distributable under LGPL license. + * See terms of license at gnu.org. + */ +package net.java.sip.communicator.impl.media.codec.audio.ilbc; + +import java.lang.*; + +/** + * @author Jean Lorchat + */ +class ilbc_encoder { + /* encoding mode, either 20 or 30 ms */ + int mode; + + /* analysis filter state */ + float anaMem[];//LPC_FILTERORDER]; + + /* old lsf parameters for interpolation */ + float lsfold[]; //LPC_FILTERORDER]; + float lsfdeqold[]; //LPC_FILTERORDER]; + + /* signal buffer for LP analysis */ + float lpc_buffer[]; //LPC_LOOKBACK + BLOCKL_MAX]; + + /* state of input HP filter */ + float hpimem[]; //4]; + + ilbc_ulp ULP_inst = null; + + /* encoder methods start here */ + + /*----------------------------------------------------------------* + * predictive noise shaping encoding of scaled start state + * (subrutine for StateSearchW) + *---------------------------------------------------------------*/ + + void AbsQuantW( + float in[], /* (i) vector to encode */ + int in_idx, + float syntDenum[], /* (i) denominator of synthesis filter */ + int syntDenum_idx, + float weightDenum[], /* (i) denominator of weighting filter */ + int weightDenum_idx, + int out[], /* (o) vector of quantizer indexes */ + int len, /* (i) length of vector to encode and + vector of quantizer indexes */ + int state_first /* (i) position of start state in the + 80 vec */ + ){ + // float *syntOut; + int syntOut; + float [] syntOutBuf = new float[ilbc_constants.LPC_FILTERORDER + + ilbc_constants.STATE_SHORT_LEN_30MS]; + float toQ, xq; + int n; + int [] index = new int[1]; + + /* initialization of buffer for filtering */ + + for (int li = 0; li < ilbc_constants.LPC_FILTERORDER; li++) { + syntOutBuf[li] = 0.0f; + } + // memset(syntOutBuf, 0, LPC_FILTERORDER*sizeof(float)); + + /* initialization of pointer for filtering */ + + // syntOut = &syntOutBuf[LPC_FILTERORDER]; + + syntOut = ilbc_constants.LPC_FILTERORDER; + + /* synthesis and weighting filters on input */ + + if (state_first != 0) { + ilbc_common.AllPoleFilter (in, in_idx, weightDenum, weightDenum_idx, + ilbc_constants.SUBL, ilbc_constants.LPC_FILTERORDER); + } else { + ilbc_common.AllPoleFilter (in, in_idx, weightDenum, weightDenum_idx, + this.ULP_inst.state_short_len - ilbc_constants.SUBL, + ilbc_constants.LPC_FILTERORDER); + } + + /* encoding loop */ + + for (n=0; n<len; n++) { + + /* time update of filter coefficients */ + + if ((state_first != 0)&&(n==ilbc_constants.SUBL)){ + syntDenum_idx += (ilbc_constants.LPC_FILTERORDER+1); + weightDenum_idx += (ilbc_constants.LPC_FILTERORDER+1); + + /* synthesis and weighting filters on input */ + ilbc_common.AllPoleFilter (in, in_idx + n, weightDenum, weightDenum_idx, + len-n, ilbc_constants.LPC_FILTERORDER); + + } else if ((state_first==0)&& + (n==(this.ULP_inst.state_short_len-ilbc_constants.SUBL))) { + syntDenum_idx += (ilbc_constants.LPC_FILTERORDER+1); + weightDenum_idx += (ilbc_constants.LPC_FILTERORDER+1); + + /* synthesis and weighting filters on input */ + ilbc_common.AllPoleFilter (in, in_idx + n, weightDenum, weightDenum_idx, len-n, + ilbc_constants.LPC_FILTERORDER); + + } + + /* prediction of synthesized and weighted input */ + + syntOutBuf[syntOut + n] = 0.0f; + ilbc_common.AllPoleFilter (syntOutBuf, syntOut + n, weightDenum, weightDenum_idx, + 1, ilbc_constants.LPC_FILTERORDER); + + /* quantization */ + + toQ = in[in_idx+n] - syntOutBuf[syntOut+n]; + + xq = sort_sq(index, 0, toQ, ilbc_constants.state_sq3Tbl, 8); + out[n]=index[0]; + syntOutBuf[syntOut + n] = ilbc_constants.state_sq3Tbl[out[n]]; + + /* update of the prediction filter */ + + ilbc_common.AllPoleFilter(syntOutBuf, syntOut + n, weightDenum, weightDenum_idx, + 1, ilbc_constants.LPC_FILTERORDER); + } + } + + /*----------------------------------------------------------------* + * encoding of start state + *---------------------------------------------------------------*/ + + void StateSearchW( + float residual[],/* (i) target residual vector */ + int residual_idx, + float syntDenum[], /* (i) lpc synthesis filter */ + int syntDenum_idx, + float weightDenum[], /* (i) weighting filter denuminator */ + int weightDenum_idx, + int idxForMax[], /* (o) quantizer index for maximum + amplitude */ + int idxVec[], /* (o) vector of quantization indexes */ + int len, /* (i) length of all vectors */ + int state_first) /* (i) position of start state in the + 80 vec */ + { + float dtmp, maxVal; + float [] tmpbuf = new float[ilbc_constants.LPC_FILTERORDER + + 2 * ilbc_constants.STATE_SHORT_LEN_30MS]; + // float *tmp, + int tmp; + float [] numerator = new float[1+ilbc_constants.LPC_FILTERORDER]; + float [] foutbuf = new float[ilbc_constants.LPC_FILTERORDER + + 2 * ilbc_constants.STATE_SHORT_LEN_30MS]; + //, *fout; + int fout; + int k; + float qmax, scal; + + /* initialization of buffers and filter coefficients */ + + for (int li = 0; li < ilbc_constants.LPC_FILTERORDER; li++) { + tmpbuf[li] = 0.0f; + foutbuf[li] = 0.0f; + } + + // memset(tmpbuf, 0, LPC_FILTERORDER*sizeof(float)); + // memset(foutbuf, 0, LPC_FILTERORDER*sizeof(float)); + + for (k=0; k < ilbc_constants.LPC_FILTERORDER; k++) { + numerator[k]=syntDenum[syntDenum_idx+ilbc_constants.LPC_FILTERORDER-k]; + } + + numerator[ilbc_constants.LPC_FILTERORDER]=syntDenum[syntDenum_idx]; + // tmp = &tmpbuf[LPC_FILTERORDER]; + tmp = ilbc_constants.LPC_FILTERORDER; + // fout = &foutbuf[LPC_FILTERORDER]; + fout = ilbc_constants.LPC_FILTERORDER; + + /* circular convolution with the all-pass filter */ + + System.arraycopy(residual, residual_idx, tmpbuf, tmp, len); + // memcpy(tmp, residual, len*sizeof(float)); + for (int li = 0; li < len; li++) + tmpbuf[tmp+len+li] = 0.0f; + // memset(tmp+len, 0, len*sizeof(float)); + ilbc_common.ZeroPoleFilter(tmpbuf, tmp, numerator, + syntDenum, syntDenum_idx, 2*len, + ilbc_constants.LPC_FILTERORDER, foutbuf, fout); + for (k=0; k<len; k++) { + foutbuf[fout+k] += foutbuf[fout+k+len]; + } + + /* identification of the maximum amplitude value */ + + maxVal = foutbuf[fout+0]; + for (k=1; k<len; k++) { + + if (foutbuf[fout+k]*foutbuf[fout+k] > maxVal*maxVal){ + maxVal = foutbuf[fout+k]; + } + } + maxVal=(float)Math.abs(maxVal); + + /* encoding of the maximum amplitude value */ + + if (maxVal < 10.0f) { + maxVal = 10.0f; + } + // log10 is since 1.5 + //maxVal = (float)Math.log10(maxVal); + maxVal = (float)(Math.log(maxVal)/Math.log(10)); + dtmp = sort_sq(idxForMax, 0, maxVal, ilbc_constants.state_frgqTbl, 64); + + /* decoding of the maximum amplitude representation value, + and corresponding scaling of start state */ + + maxVal = ilbc_constants.state_frgqTbl[idxForMax[0]]; + qmax = (float)Math.pow(10,maxVal); + scal = 4.5f / qmax; + for (k=0; k<len; k++){ + foutbuf[fout+k] *= scal; + } + + /* predictive noise shaping encoding of scaled start state */ + + AbsQuantW(foutbuf, fout,syntDenum, syntDenum_idx, + weightDenum, weightDenum_idx, idxVec, len, state_first); + } + + + /*----------------------------------------------------------------* + * conversion from lpc coefficients to lsf coefficients + *---------------------------------------------------------------*/ + + void a2lsf( + float freq[],/* (o) lsf coefficients */ + int freq_idx, + float a[]) /* (i) lpc coefficients */ + { + float [] steps = {(float)0.00635f, (float)0.003175f, (float)0.0015875f, + (float)0.00079375f}; + float step; + int step_idx; + int lsp_index; + float [] p = new float[ilbc_constants.LPC_HALFORDER]; + float [] q = new float[ilbc_constants.LPC_HALFORDER]; + float [] p_pre = new float[ilbc_constants.LPC_HALFORDER]; + float [] q_pre = new float[ilbc_constants.LPC_HALFORDER]; + int old_p = 0, old_q = 1; + //float *old; + float [] olds = new float[2]; + int old; + // float *pq_coef; + float [] pq_coef; + float omega, old_omega; + int i; + float hlp, hlp1, hlp2, hlp3, hlp4, hlp5; + + for (i=0; i < ilbc_constants.LPC_HALFORDER; i++) { + p[i] = (float)-1.0f * (a[i + 1] + a[ilbc_constants.LPC_FILTERORDER - i]); + q[i] = a[ilbc_constants.LPC_FILTERORDER - i] - a[i + 1]; + } + + p_pre[0] = (float) -1.0f - p[0]; + p_pre[1] = - p_pre[0] - p[1]; + p_pre[2] = - p_pre[1] - p[2]; + p_pre[3] = - p_pre[2] - p[3]; + p_pre[4] = - p_pre[3] - p[4]; + p_pre[4] = p_pre[4] / 2; + + q_pre[0] = (float) 1.0f - q[0]; + q_pre[1] = q_pre[0] - q[1]; + q_pre[2] = q_pre[1] - q[2]; + q_pre[3] = q_pre[2] - q[3]; + q_pre[4] = q_pre[3] - q[4]; + q_pre[4] = q_pre[4] / 2; + + omega = 0.0f; + + old_omega = 0.0f; + + olds[old_p] = ilbc_constants.DOUBLE_MAX; + olds[old_q] = ilbc_constants.DOUBLE_MAX; + + /* Here we loop through lsp_index to find all the + LPC_FILTERORDER roots for omega. */ + + for (lsp_index = 0; lsp_index < ilbc_constants.LPC_FILTERORDER; lsp_index++) { + + /* Depending on lsp_index being even or odd, we + alternatively solve the roots for the two LSP equations. */ + + + if ((lsp_index & 0x1) == 0) { + pq_coef = p_pre; + old = old_p; + } else { + pq_coef = q_pre; + old = old_q; + } + + /* Start with low resolution grid */ + + for (step_idx = 0, step = steps[step_idx]; + step_idx < ilbc_constants.LSF_NUMBER_OF_STEPS;){ + + /* cos(10piw) + pq(0)cos(8piw) + pq(1)cos(6piw) + + pq(2)cos(4piw) + pq(3)cod(2piw) + pq(4) */ + + hlp = (float)Math.cos(omega * ilbc_constants.TWO_PI); + hlp1 = 2.0f * hlp + pq_coef[0]; + hlp2 = 2.0f * hlp * hlp1 - (float)1.0 + pq_coef[1]; + hlp3 = 2.0f * hlp * hlp2 - hlp1 + pq_coef[2]; + hlp4 = 2.0f * hlp * hlp3 - hlp2 + pq_coef[3]; + hlp5 = hlp * hlp4 - hlp3 + pq_coef[4]; + + + if (((hlp5 * (olds[old])) <= 0.0f) || (omega >= 0.5)){ + + if (step_idx == (ilbc_constants.LSF_NUMBER_OF_STEPS - 1)){ + + if ((float)Math.abs(hlp5) >= Math.abs(olds[old])) { + //System.out.println("acces index " + freq_idx + lsp_index); + freq[freq_idx+lsp_index] = omega - step; + } else { + //System.out.println("acces index " + freq_idx + lsp_index); + freq[freq_idx+lsp_index] = omega; + } + + if ((olds[old]) >= 0.0f){ + olds[old] = -1.0f * ilbc_constants.DOUBLE_MAX; + } else { + olds[old] = ilbc_constants.DOUBLE_MAX; + } + + omega = old_omega; + step_idx = 0; + + step_idx = ilbc_constants.LSF_NUMBER_OF_STEPS; + } else { + + if (step_idx == 0) { + old_omega = omega; + } + + step_idx++; + omega -= steps[step_idx]; + + /* Go back one grid step */ + + step = steps[step_idx]; + } + } else { + + /* increment omega until they are of different sign, + and we know there is at least one root between omega + and old_omega */ + olds[old] = hlp5; + omega += step; + } + } + } + + for (i = 0; i < ilbc_constants.LPC_FILTERORDER; i++) { + //System.out.println("acces index " + freq_idx + i); + freq[freq_idx+i] = freq[freq_idx+i] * ilbc_constants.TWO_PI; + } + } + + /*----------------------------------------------------------------* + * lpc analysis (subrutine to LPCencode) + *---------------------------------------------------------------*/ + + void SimpleAnalysis( + float lsf[], /* (o) lsf coefficients */ + float data[]) /* (i) new data vector */ + { + int k, is; + float [] temp = new float[ilbc_constants.BLOCKL_MAX]; + float [] lp = new float[ilbc_constants.LPC_FILTERORDER + 1]; + float [] lp2 = new float[ilbc_constants.LPC_FILTERORDER + 1]; + float [] r = new float[ilbc_constants.LPC_FILTERORDER + 1]; + + is=ilbc_constants.LPC_LOOKBACK+ilbc_constants.BLOCKL_MAX-this.ULP_inst.blockl; + // System.out.println("copie 1"); +// System.out.println("\nInformations de copie : \nbuffer source : " + data.length + " octets\n"+ +// "buffer cible : " + this.lpc_buffer.length + "octets\n" + +// " offset : " + is + "octets\n" + +// "longueur de la copie : " + this.ULP_inst.blockl); + System.arraycopy(data, 0, this.lpc_buffer, is, this.ULP_inst.blockl); +// memcpy(iLBCenc_inst->lpc_buffer+is,data,iLBCenc_inst->blockl*sizeof(float)); + + /* No lookahead, last window is asymmetric */ + + for (k = 0; k < this.ULP_inst.lpc_n; k++) { + + is = ilbc_constants.LPC_LOOKBACK; + + if (k < (this.ULP_inst.lpc_n - 1)) { + window(temp, ilbc_constants.lpc_winTbl, this.lpc_buffer, 0, + ilbc_constants.BLOCKL_MAX); + } else { + window(temp, ilbc_constants.lpc_asymwinTbl, + this.lpc_buffer, is, ilbc_constants.BLOCKL_MAX); + } + + autocorr(r, temp, ilbc_constants.BLOCKL_MAX, ilbc_constants.LPC_FILTERORDER); + window(r, r, ilbc_constants.lpc_lagwinTbl, 0, ilbc_constants.LPC_FILTERORDER + 1); + + levdurb(lp, temp, r, ilbc_constants.LPC_FILTERORDER); + ilbc_common.bwexpand(lp2, 0, lp, ilbc_constants.LPC_CHIRP_SYNTDENUM, + ilbc_constants.LPC_FILTERORDER+1); + + a2lsf(lsf, k * ilbc_constants.LPC_FILTERORDER, lp2); + } + is=ilbc_constants.LPC_LOOKBACK+ilbc_constants.BLOCKL_MAX-this.ULP_inst.blockl; +// System.out.println("copie 2"); + System.arraycopy(this.lpc_buffer, ilbc_constants.LPC_LOOKBACK + ilbc_constants.BLOCKL_MAX - is, + this.lpc_buffer, 0, is); +// memmove(iLBCenc_inst->lpc_buffer, +// iLBCenc_inst->lpc_buffer+LPC_LOOKBACK+BLOCKL_MAX-is, +// is*sizeof(float)); + } + + /*----------------------------------------------------------------* + * lsf interpolator and conversion from lsf to a coefficients + * (subrutine to SimpleInterpolateLSF) + *---------------------------------------------------------------*/ + + void LSFinterpolate2a_enc( + float a[], /* (o) lpc coefficients */ + float lsf1[],/* (i) first set of lsf coefficients */ + float lsf2[],/* (i) second set of lsf coefficients */ + int lsf2_idx, + float coef, /* (i) weighting coefficient to use between + lsf1 and lsf2 */ + long length /* (i) length of coefficient vectors */ + ){ + float [] lsftmp = new float[ilbc_constants.LPC_FILTERORDER]; + + ilbc_common.interpolate(lsftmp, lsf1, lsf2, lsf2_idx, coef, ((int)length)); + ilbc_common.lsf2a(a, lsftmp); + } + + /*----------------------------------------------------------------* + * lsf interpolator (subrutine to LPCencode) + *---------------------------------------------------------------*/ + + void SimpleInterpolateLSF( + float syntdenum[], /* (o) the synthesis filter denominator + resulting from the quantized + interpolated lsf */ + float weightdenum[], /* (o) the weighting filter denominator + resulting from the unquantized + interpolated lsf */ + float lsf[], /* (i) the unquantized lsf coefficients */ + float lsfdeq[], /* (i) the dequantized lsf coefficients */ + float lsfold[], /* (i) the unquantized lsf coefficients of + the previous signal frame */ + float lsfdeqold[], /* (i) the dequantized lsf coefficients of + the previous signal frame */ + int length) /* (i) should equate LPC_FILTERORDER */ + { + int i, pos, lp_length; + float [] lp = new float[ilbc_constants.LPC_FILTERORDER + 1]; + int lsf2, lsfdeq2; + + lsf2 = length; + lsfdeq2 = length; +// lsf2 = lsf + length; +// lsfdeq2 = lsfdeq + length; + lp_length = length + 1; + + if (this.ULP_inst.mode==30) { + /* sub-frame 1: Interpolation between old and first + + set of lsf coefficients */ + + LSFinterpolate2a_enc(lp, lsfdeqold, lsfdeq, 0, + ilbc_constants.lsf_weightTbl_30ms[0], length); + System.arraycopy(lp, 0, syntdenum, 0, lp_length); + // memcpy(syntdenum,lp,lp_length*sizeof(float)); + LSFinterpolate2a_enc(lp, lsfold, lsf, 0, + ilbc_constants.lsf_weightTbl_30ms[0], length); + ilbc_common.bwexpand(weightdenum, 0, lp, + ilbc_constants.LPC_CHIRP_WEIGHTDENUM, + lp_length); + + /* sub-frame 2 to 6: Interpolation between first + and second set of lsf coefficients */ + + pos = lp_length; + for (i = 1; i < this.ULP_inst.nsub; i++) { + LSFinterpolate2a_enc(lp, lsfdeq, lsfdeq, lsfdeq2, + ilbc_constants.lsf_weightTbl_30ms[i], length); + System.arraycopy(lp, 0, syntdenum, pos, lp_length); + // memcpy(syntdenum + pos,lp,lp_length*sizeof(float)); + + LSFinterpolate2a_enc(lp, lsf, lsf, lsf2, + ilbc_constants.lsf_weightTbl_30ms[i], length); + ilbc_common.bwexpand(weightdenum, pos, lp, + ilbc_constants.LPC_CHIRP_WEIGHTDENUM, lp_length); + pos += lp_length; + } + } + else { + pos = 0; + for (i = 0; i < this.ULP_inst.nsub; i++) { + //System.out.println("ici ?"); + LSFinterpolate2a_enc(lp, lsfdeqold, lsfdeq, 0, + ilbc_constants.lsf_weightTbl_20ms[i], length); + //System.out.println("ici !"); + System.arraycopy(lp, 0, syntdenum, pos, lp_length); + for (int li = 0; li < lp_length; li++) + //System.out.println("interpolate syntdenum [" + (li+pos) +"] is worth " + syntdenum[li+pos]); + // memcpy(syntdenum+pos,lp,lp_length*sizeof(float)); + LSFinterpolate2a_enc(lp, lsfold, lsf, 0, + ilbc_constants.lsf_weightTbl_20ms[i], length); + ilbc_common.bwexpand(weightdenum, pos, lp, + ilbc_constants.LPC_CHIRP_WEIGHTDENUM, lp_length); + pos += lp_length; + } + } + + /* update memory */ + + if (this.ULP_inst.mode==30) { + System.arraycopy(lsf, lsf2, lsfold, 0, length); +// memcpy(lsfold, lsf2, length*sizeof(float)); + System.arraycopy(lsfdeq, lsfdeq2, lsfdeqold, 0, length); +// memcpy(lsfdeqold, lsfdeq2, length*sizeof(float)); + } + else { + System.arraycopy(lsf, 0, lsfold, 0, length); +// memcpy(lsfold, lsf, length*sizeof(float)); + System.arraycopy(lsfdeq, 0, lsfdeqold, 0, length); +// memcpy(lsfdeqold, lsfdeq, length*sizeof(float)); + + } + } + + /*----------------------------------------------------------------* + * lsf quantizer (subrutine to LPCencode) + *---------------------------------------------------------------*/ + + void SimplelsfQ( + float lsfdeq[], /* (o) dequantized lsf coefficients + (dimension FILTERORDER) */ + int index[], /* (o) quantization index */ + float lsf[], /* (i) the lsf coefficient vector to be + quantized (dimension FILTERORDER ) */ + int lpc_n /* (i) number of lsf sets to quantize */ + ){ + /* Quantize first LSF with memoryless split VQ */ + SplitVQ(lsfdeq, 0, index, 0, lsf, 0, ilbc_constants.lsfCbTbl, + ilbc_constants.LSF_NSPLIT, ilbc_constants.dim_lsfCbTbl, + ilbc_constants.size_lsfCbTbl); + + if (lpc_n==2) { + /* Quantize second LSF with memoryless split VQ */ + SplitVQ(lsfdeq, ilbc_constants.LPC_FILTERORDER, + index, ilbc_constants.LSF_NSPLIT, + lsf, ilbc_constants.LPC_FILTERORDER, + ilbc_constants.lsfCbTbl, + ilbc_constants.LSF_NSPLIT, + ilbc_constants.dim_lsfCbTbl, + ilbc_constants.size_lsfCbTbl); + } + } + + /*----------------------------------------------------------------* + * lpc encoder + *---------------------------------------------------------------*/ + + void LPCencode( + float syntdenum[], /* (i/o) synthesis filter coefficients + before/after encoding */ + float weightdenum[], /* (i/o) weighting denumerator + coefficients before/after + encoding */ + int lsf_index[], /* (o) lsf quantization index */ + float data[]) /* (i) lsf coefficients to quantize */ + { + float [] lsf = new float[ilbc_constants.LPC_FILTERORDER * ilbc_constants.LPC_N_MAX]; + float [] lsfdeq= new float[ilbc_constants.LPC_FILTERORDER * ilbc_constants.LPC_N_MAX]; + int change = 0; + + SimpleAnalysis(lsf, data); + // for (int li = 0; li < ilbc_constants.LPC_FILTERORDER * ilbc_constants.LPC_N_MAX; li++) + // System.out.println("postSA n-" + li + " is worth " + lsf[li]); + // for (int li = 0; li < ilbc_constants.BLOCKL_MAX; li++) + // System.out.println("data postSA n-" + li + " is worth " + data[li]); + SimplelsfQ(lsfdeq, lsf_index, lsf, this.ULP_inst.lpc_n); + // for (int li = 0; li < ilbc_constants.LPC_FILTERORDER * ilbc_constants.LPC_N_MAX; li++) + // System.out.println("postSlsfQ n-" + li + " is worth " + lsfdeq[li]); + // for (int li = 0; li < lsf_index.length; li++) + // System.out.println("index postSlsfQ n-" + li + " is worth " + lsf_index[li]); + + change = ilbc_common.LSF_check(lsfdeq, ilbc_constants.LPC_FILTERORDER, this.ULP_inst.lpc_n); + //System.out.println("check gives " + change); + SimpleInterpolateLSF(syntdenum, weightdenum, + lsf, lsfdeq, this.lsfold, + this.lsfdeqold, ilbc_constants.LPC_FILTERORDER); + // for (int li = 0; li < syntdenum.length; li++) + // System.out.println("syntdenum[" + li +"] is worth " + syntdenum[li]); + } + + public void iCBSearch( + int index[], /* (o) Codebook indices */ + int index_idx, + int gain_index[],/* (o) Gain quantization indices */ + int gain_index_idx, + + float intarget[],/* (i) Target vector for encoding */ + int intarget_idx, + float mem[], /* (i) Buffer for codebook construction */ + int mem_idx, + int lMem, /* (i) Length of buffer */ + int lTarget, /* (i) Length of vector */ + int nStages, /* (i) Number of codebook stages */ + float weightDenum[], /* (i) weighting filter coefficients */ + int weightDenum_idx, + float weightState[], /* (i) weighting filter state */ + int block) /* (i) the sub-block number */ + { + int i, j, icount, stage, best_index, range, counter; + float max_measure, gain, measure, crossDot, ftmp; + float [] gains = new float[ilbc_constants.CB_NSTAGES]; + float [] target = new float[ilbc_constants.SUBL]; + int base_index, sInd, eInd, base_size; + int sIndAug=0, eIndAug=0; + float [] buf = new float[ilbc_constants.CB_MEML+ilbc_constants.SUBL+2*ilbc_constants.LPC_FILTERORDER]; + float [] invenergy = new float[ilbc_constants.CB_EXPAND*128]; + float [] energy = new float[ilbc_constants.CB_EXPAND*128]; + // float *pp, *ppi=0, *ppo=0, *ppe=0; + int pp, ppi = 0, ppo = 0, ppe = 0; + float [] ppt; + float [] cbvectors = new float[ilbc_constants.CB_MEML]; + float tene, cene; + float [] cvec = new float[ilbc_constants.SUBL]; + float [] aug_vec = new float[ilbc_constants.SUBL]; + + float [] a = new float[1]; + int [] b = new int[1]; + float [] c = new float[1]; + + for (int li = 0; li < ilbc_constants.SUBL; li++) + cvec[li] = 0.0f; + // memset(cvec,0,SUBL*sizeof(float)); + + /* Determine size of codebook sections */ + + base_size=lMem-lTarget+1; + + if (lTarget == ilbc_constants.SUBL) { + base_size=lMem-lTarget+1+lTarget/2; + } + + /* setup buffer for weighting */ + + System.arraycopy(weightState, 0, buf, 0, ilbc_constants.LPC_FILTERORDER); +// memcpy(buf,weightState,sizeof(float)*LPC_FILTERORDER); + System.arraycopy(mem, mem_idx, buf, ilbc_constants.LPC_FILTERORDER, lMem); +// memcpy(buf+LPC_FILTERORDER,mem,lMem*sizeof(float)); + System.arraycopy(intarget, intarget_idx, buf, ilbc_constants.LPC_FILTERORDER+lMem, lTarget); +// memcpy(buf+LPC_FILTERORDER+lMem,intarget,lTarget*sizeof(float)); + + //System.out.println("beginning of mem"); +// for (int li = 0; li < lMem; li++) +// System.out.println("mem[" + li + "] = " + mem[li+mem_idx]); +// System.out.println("end of mem"); + + +// System.out.println("plages : [0-" + ilbc_constants.LPC_FILTERORDER + +// "], puis [" + ilbc_constants.LPC_FILTERORDER + "-" + (ilbc_constants.LPC_FILTERORDER + lMem) + +// "], puis [" + (ilbc_constants.LPC_FILTERORDER + lMem) + +// "-" + (ilbc_constants.LPC_FILTERORDER + lMem + lTarget) + "]"); + +// System.out.println("beginning of buffer"); + +// for (int li = 0; li < buf.length; li++) +// System.out.println("buffer[" + li + "] = " + buf[li]); + +// System.out.println("end of buffer"); + /* weighting */ + + ilbc_common.AllPoleFilter(buf, ilbc_constants.LPC_FILTERORDER, weightDenum, weightDenum_idx, + lMem+lTarget, ilbc_constants.LPC_FILTERORDER); + + /* Construct the codebook and target needed */ + + System.arraycopy(buf, ilbc_constants.LPC_FILTERORDER + lMem, target, 0, lTarget); + // memcpy(target, buf+LPC_FILTERORDER+lMem, lTarget*sizeof(float)); + + tene=0.0f; + + for (i=0; i<lTarget; i++) { + tene+=target[i]*target[i]; + } + + /* Prepare search over one more codebook section. This section + is created by filtering the original buffer with a filter. */ + + filteredCBvecs(cbvectors, buf, ilbc_constants.LPC_FILTERORDER, lMem); + + /* The Main Loop over stages */ + + for (stage=0; stage<nStages; stage++) { + + range = ilbc_constants.search_rangeTbl[block][stage]; + + /* initialize search measure */ + + max_measure = (float)-10000000.0f; + gain = (float)0.0f; + best_index = 0; + + /* Compute cross dot product between the target + and the CB memory */ + + crossDot=0.0f; + pp=ilbc_constants.LPC_FILTERORDER+lMem-lTarget; +// pp=buf+ilbc_constants.LPC_FILTERORDER+lMem-lTarget; + for (j=0; j<lTarget; j++) { + crossDot += target[j]*(buf[pp]); + pp++; + } + + if (stage==0) { + + /* Calculate energy in the first block of + 'lTarget' samples. */ + ppe = 0; + ppi = ilbc_constants.LPC_FILTERORDER+lMem-lTarget-1; + ppo = ilbc_constants.LPC_FILTERORDER+lMem-1; +// ppe = energy; +// ppi = buf+ilbc_constants.LPC_FILTERORDER+lMem-lTarget-1; +// ppo = buf+ilbc_constants.LPC_FILTERORDER+lMem-1; + + energy[ppe]=0.0f; + pp=ilbc_constants.LPC_FILTERORDER+lMem-lTarget; +// pp=buf+ilbc_constants.LPC_FILTERORDER+lMem-lTarget; + for (j=0; j<lTarget; j++) { + energy[ppe]+=(buf[pp])*(buf[pp]); + pp++; + } + + if (energy[ppe] > 0.0f) { + invenergy[0] = (float) 1.0f / (energy[ppe] + ilbc_constants.EPS); + } else { + invenergy[0] = (float) 0.0f; + + } + ppe++; + + measure=(float)-10000000.0f; + + if (crossDot > 0.0f) { + measure = crossDot*crossDot*invenergy[0]; + } + } + else { + measure = crossDot*crossDot*invenergy[0]; + } + + /* check if measure is better */ + ftmp = crossDot*invenergy[0]; + + if ((measure>max_measure) && ((float)Math.abs(ftmp) < ilbc_constants.CB_MAXGAIN)) { + best_index = 0; + max_measure = measure; + gain = ftmp; + } + + /* loop over the main first codebook section, + full search */ + + for (icount=1; icount<range; icount++) { + + /* calculate measure */ + + crossDot=0.0f; + pp = ilbc_constants.LPC_FILTERORDER+lMem-lTarget-icount; +// pp = buf+LPC_FILTERORDER+lMem-lTarget-icount; + + for (j=0; j<lTarget; j++) { + crossDot += target[j]*(buf[pp]); + pp++; + } + + if (stage==0) { + energy[ppe] = energy[icount-1] + (buf[ppi])*(buf[ppi]) - + (buf[ppo])*(buf[ppo]); + ppe++; + ppo--; + ppi--; + + if (energy[icount]>0.0f) { + invenergy[icount] = + (float)1.0f/(energy[icount]+ilbc_constants.EPS); + } else { + invenergy[icount] = (float) 0.0f; + } + + measure=(float)-10000000.0f; + + if (crossDot > 0.0f) { + measure = crossDot*crossDot*invenergy[icount]; + } + } + else { + measure = crossDot*crossDot*invenergy[icount]; + } + + /* check if measure is better */ + ftmp = crossDot*invenergy[icount]; + + if ((measure>max_measure) && ((float)Math.abs(ftmp) < ilbc_constants.CB_MAXGAIN)) { + best_index = icount; + max_measure = measure; + gain = ftmp; + } + } + + /* Loop over augmented part in the first codebook + * section, full search. + * The vectors are interpolated. + */ + + if (lTarget == ilbc_constants.SUBL) { + + /* Search for best possible cb vector and + compute the CB-vectors' energy. */ + a[0] = max_measure; + b[0] = best_index; + c[0] = gain; + searchAugmentedCB(20, 39, stage, base_size-lTarget/2, + target, buf, ilbc_constants.LPC_FILTERORDER+lMem, + a, b, c, energy, invenergy); + max_measure = a[0]; + best_index = b[0]; + gain = c[0]; + } + + /* set search range for following codebook sections */ + + // System.out.println("best index : " + best_index); + + base_index = best_index; + + /* unrestricted search */ + + if (ilbc_constants.CB_RESRANGE == -1) { + // System.out.println("on met a 0"); + sInd = 0; + eInd = range - 1; + sIndAug = 20; + eIndAug = 39; + } + + /* restricted search around best index from first + codebook section */ + + else { + /* Initialize search indices */ + sIndAug=0; + eIndAug=0; + sInd=base_index-ilbc_constants.CB_RESRANGE/2; + // System.out.println("on met a " + base_index + " - " + ilbc_constants.CB_RESRANGE/2 + " = " + sInd); + eInd=sInd+ilbc_constants.CB_RESRANGE; + + if (lTarget==ilbc_constants.SUBL) { + + if (sInd<0) { + + sIndAug = 40 + sInd; + eIndAug = 39; + // System.out.println("On met encore a 0"); + sInd=0; + + } else if ( base_index < (base_size-20) ) { + + if (eInd > range) { + sInd -= (eInd-range); + // System.out.println("on retire " + eInd + " - " + range + " pour arriver a " + sInd); + eInd = range; + } + } else { /* base_index >= (base_size-20) */ + + if (sInd < (base_size-20)) { + sIndAug = 20; + sInd = 0; + // System.out.println("on remet encore a 0"); + eInd = 0; + eIndAug = 19 + ilbc_constants.CB_RESRANGE; + + if(eIndAug > 39) { + eInd = eIndAug-39; + eIndAug = 39; + } + } else { + sIndAug = 20 + sInd - (base_size-20); + eIndAug = 39; + sInd = 0; + // System.out.println("on remetz4 a zero"); + eInd = ilbc_constants.CB_RESRANGE - (eIndAug-sIndAug+1); + } + } + + } else { /* lTarget = 22 or 23 */ + + if (sInd < 0) { + eInd -= sInd; + + sInd = 0; + // System.out.println("on remet x5 a zero"); + } + + if(eInd > range) { + sInd -= (eInd - range); + // System.out.println("on retire " + eInd + " - " + range + " pour arriver a " + sInd); + eInd = range; + } + } + } + + /* search of higher codebook section */ + + /* index search range */ + counter = sInd; + // System.out.println("on ajoute " + base_size + " pour arriver a " + sInd); + sInd += base_size; + eInd += base_size; + + + if (stage==0) { + // ppe = energy+base_size; + ppe = base_size; + energy[ppe]=0.0f; + + pp=lMem-lTarget; + // pp=cbvectors+lMem-lTarget; + for (j=0; j<lTarget; j++) { + energy[ppe] += (cbvectors[pp])*(cbvectors[pp]); + pp++; + } + + ppi = lMem - 1 - lTarget; + ppo = lMem - 1; +// ppi = cbvectors + lMem - 1 - lTarget; +// ppo = cbvectors + lMem - 1; + + for (j=0; j<(range-1); j++) { + energy[(ppe+1)] = energy[ppe] + + (cbvectors[ppi])*(cbvectors[ppi]) - + (cbvectors[ppo])*(cbvectors[ppo]); + ppo--; + ppi--; + ppe++; + } + } + + /* loop over search range */ + + for (icount=sInd; icount<eInd; icount++) { + + /* calculate measure */ + + crossDot=0.0f; + pp=lMem - (counter++) - lTarget; +// pp=cbvectors + lMem - (counter++) - lTarget; + +// System.out.println("lMem : " + lMem); +// System.out.println("counter : " + counter); +// System.out.println("target : " + lTarget); + + for (j=0;j<lTarget;j++) { + + crossDot += target[j]*(cbvectors[pp]); + pp++; + } + + if (energy[icount]>0.0f) { + invenergy[icount] =(float)1.0f/(energy[icount]+ilbc_constants.EPS); + } else { + invenergy[icount] =(float)0.0f; + } + + if (stage==0) { + + measure=(float)-10000000.0f; + + if (crossDot > 0.0f) { + measure = crossDot*crossDot* + invenergy[icount]; + } + } + else { + measure = crossDot*crossDot*invenergy[icount]; + } + + /* check if measure is better */ + ftmp = crossDot*invenergy[icount]; + + if ((measure > max_measure) && ((float)Math.abs(ftmp)<ilbc_constants.CB_MAXGAIN)) { + best_index = icount; + max_measure = measure; + gain = ftmp; + } + } + + /* Search the augmented CB inside the limited range. */ + + if ((lTarget==ilbc_constants.SUBL)&&(sIndAug!=0)) { + a[0] = max_measure; + b[0] = best_index; + c[0] = gain; + searchAugmentedCB(sIndAug, eIndAug, stage, + 2*base_size-20, target, cbvectors, lMem, + a, b, c, energy, invenergy); + max_measure = a[0]; + best_index = b[0]; + gain = c[0]; + } + + /* record best index */ + + index[index_idx+stage] = best_index; + + /* gain quantization */ + + if (stage==0){ + + if (gain<0.0f){ + gain = 0.0f; + } + + if (gain > ilbc_constants.CB_MAXGAIN) { + gain = (float)ilbc_constants.CB_MAXGAIN; + } + gain = ilbc_common.gainquant(gain, 1.0f, 32, gain_index, gain_index_idx + stage); + } + else { + if (stage==1) { + gain = ilbc_common.gainquant(gain, (float)(float)Math.abs(gains[stage-1]), + 16, gain_index, gain_index_idx + stage); + } else { + gain = ilbc_common.gainquant(gain, (float)(float)Math.abs(gains[stage-1]), + 8, gain_index, gain_index_idx + stage); + } + } + + /* Extract the best (according to measure) + codebook vector */ + + if (lTarget==(ilbc_constants.STATE_LEN - this.ULP_inst.state_short_len)) { + + if (index[index_idx+stage]<base_size) { + pp=ilbc_constants.LPC_FILTERORDER+lMem-lTarget-index[index_idx+stage]; +// pp=buf+ilbc_constants.LPC_FILTERORDER+lMem-lTarget-index[stage]; + ppt = buf; + } else { + pp=lMem-lTarget-index[index_idx+stage]+base_size; +// pp=cbvectors+lMem-lTarget-index[stage]+base_size; + ppt = cbvectors; + } + } else { + + if (index[index_idx+stage]<base_size) { + if (index[index_idx+stage]<(base_size-20)) { + pp=ilbc_constants.LPC_FILTERORDER+lMem-lTarget-index[index_idx+stage]; + // pp=buf+LPC_FILTERORDER+lMem-lTarget-index[stage]; + ppt = buf; + } else { + createAugmentedVec(index[index_idx+stage]-base_size+40, + buf, ilbc_constants.LPC_FILTERORDER+lMem,aug_vec); + // pp=aug_vec; + pp = 0; + ppt = aug_vec; + } + } else { + int filterno, position; + + filterno=index[index_idx+stage]/base_size; + position=index[index_idx+stage]-filterno*base_size; + + if (position<(base_size-20)) { + pp=filterno*lMem-lTarget-index[index_idx+stage]+filterno*base_size; +// pp=cbvectors+filterno*lMem-lTarget-index[stage]+filterno*base_size; + ppt = cbvectors; + } else { + createAugmentedVec(index[index_idx+stage]-(filterno+1)*base_size+40, + cbvectors, filterno*lMem,aug_vec); + // pp=aug_vec; + pp = 0; + ppt = aug_vec; + } + } + } + + /* Subtract the best codebook vector, according + to measure, from the target vector */ + + for (j=0;j<lTarget;j++) { + cvec[j] += gain*(ppt[pp]); + target[j] -= gain*(ppt[pp]); + pp++; + } + + /* record quantized gain */ + + gains[stage]=gain; + + }/* end of Main Loop. for (stage=0;... */ + + /* Gain adjustment for energy matching */ + cene=0.0f; + for (i=0; i<lTarget; i++) { + cene+=cvec[i]*cvec[i]; + } + j=gain_index[gain_index_idx + 0]; + + for (i=gain_index[gain_index_idx + 0]; i<32; i++) { + ftmp=cene*ilbc_constants.gain_sq5Tbl[i]*ilbc_constants.gain_sq5Tbl[i]; + + if ((ftmp<(tene*gains[0]*gains[0])) && + (ilbc_constants.gain_sq5Tbl[j]<(2.0f*gains[0]))) { + j=i; + } + } + gain_index[gain_index_idx + 0]=j; + } + + public void index_conv_enc(int index[]) /* (i/o) Codebook indexes */ + { + int k; + + for (k=1; k < ilbc_constants.CB_NSTAGES; k++) { + + if ((index[k]>=108)&&(index[k]<172)) { + index[k]-=64; + } else if (index[k]>=236) { + index[k]-=128; + } else { + /* ERROR */ + } + } + } + + public void hpInput( + float In[], /* (i) vector to filter */ + int len, /* (i) length of vector to filter */ + float Out[], /* (o) the resulting filtered vector */ + float mem[]) /* (i/o) the filter state */ + { + int i; + // float *pi, *po; + int pi, po; + + /* all-zero section*/ + + // pi = &In[0]; + pi = 0; + // po = &Out[0]; + po = 0; + + for (i=0; i<len; i++) { + // System.out.println(Out[po] + " + " + ilbc_constants.hpi_zero_coefsTbl[0] + " * " + In[pi] + "((" + ilbc_constants.hpi_zero_coefsTbl[0] * In[pi]); + Out[po] = ilbc_constants.hpi_zero_coefsTbl[0] * (In[pi]); + // System.out.println("then *po=" + Out[po]); + // System.out.println(Out[po] + " + " + ilbc_constants.hpi_zero_coefsTbl[1] +" * "+ mem[0] + "((" + ilbc_constants.hpi_zero_coefsTbl[1] * mem[0]); + Out[po] += ilbc_constants.hpi_zero_coefsTbl[1] * mem[0]; + // System.out.println("then *po=" + Out[po]); + // System.out.println(Out[po] + " + " + ilbc_constants.hpi_zero_coefsTbl[2] + " * " + mem[1] + "((" + ilbc_constants.hpi_zero_coefsTbl[2] * mem[1]); + Out[po] += ilbc_constants.hpi_zero_coefsTbl[2] * mem[1]; + // System.out.println("then *po=" + Out[po]); + + mem[1] = mem[0]; + mem[0] = In[pi]; + po++; + pi++; + } + + /* all-pole section*/ + + // po = &Out[0]; + po = 0; + for (i=0; i<len; i++) { + // System.out.println("(part 2-"+i+") *po=" + Out[po]); + // System.out.println(Out[po] + " - " + ilbc_constants.hpi_pole_coefsTbl[1] + " * " + mem[2] + " ((" + ilbc_constants.hpi_pole_coefsTbl[1] * mem[2]); + Out[po] -= ilbc_constants.hpi_pole_coefsTbl[1] * mem[2]; + // System.out.println("then *po=" + Out[po]); + // System.out.println(Out[po] + " - " + ilbc_constants.hpi_pole_coefsTbl[2] + " * " + mem[3] + " ((" + ilbc_constants.hpi_pole_coefsTbl[2] * mem[3]); + Out[po] -= ilbc_constants.hpi_pole_coefsTbl[2] * mem[3]; + // System.out.println("2then *po=" + Out[po]); + + mem[3] = mem[2]; + mem[2] = Out[po]; + po++; + } + } + + + /*----------------------------------------------------------------* + * calculation of auto correlation + *---------------------------------------------------------------*/ + + public void autocorr( + float r[], /* (o) autocorrelation vector */ + float x[], /* (i) data vector */ + int N, /* (i) length of data vector */ + int order) /* largest lag for calculated + autocorrelations */ + { + int lag, n; + float sum; + + for (lag = 0; lag <= order; lag++) { + sum = 0; + for (n = 0; n < N - lag; n++) { + sum += x[n] * x[n+lag]; + } + r[lag] = sum; + } + } + + /*----------------------------------------------------------------* + * window multiplication + *---------------------------------------------------------------*/ + + public void window( + float z[], /* (o) the windowed data */ + float x[], /* (i) the original data vector */ + float y[], /* (i) the window */ + int y_idx, + int N) /* (i) length of all vectors */ + { + int i; + + for (i = 0; i < N; i++) { + z[i] = x[i] * y[i+y_idx]; + } + } + + /*----------------------------------------------------------------* + * levinson-durbin solution for lpc coefficients + *---------------------------------------------------------------*/ + + public void levdurb( + float a[], /* (o) lpc coefficient vector starting + with 1.0f */ + float k[], /* (o) reflection coefficients */ + float r[], /* (i) autocorrelation vector */ + int order) /* (i) order of lpc filter */ + { + float sum, alpha; + int m, m_h, i; + + a[0] = 1.0f; + + if (r[0] < ilbc_constants.EPS) { /* if r[0] <= 0, set LPC coeff. to zero */ + for (i = 0; i < order; i++) { + k[i] = 0; + a[i+1] = 0; + } + } else { + a[1] = k[0] = -r[1]/r[0]; + alpha = r[0] + r[1] * k[0]; + for (m = 1; m < order; m++){ + sum = r[m + 1]; + for (i = 0; i < m; i++){ + sum += a[i+1] * r[m - i]; + } + k[m] = -sum / alpha; + alpha += k[m] * sum; + m_h = (m + 1) >> 1; + for (i = 0; i < m_h; i++){ + sum = a[i+1] + k[m] * a[m - i]; + a[m - i] += k[m] * a[i+1]; + a[i+1] = sum; + } + a[m+1] = k[m]; + } + } + } + + /*----------------------------------------------------------------* + * vector quantization + *---------------------------------------------------------------*/ + + public void vq( + float Xq[], /* (o) the quantized vector */ + int Xq_idx, + int index[], /* (o) the quantization index */ + int index_idx, + float CB[],/* (i) the vector quantization codebook */ + int CB_idx, + float X[], /* (i) the vector to quantize */ + int X_idx, + int n_cb, /* (i) the number of vectors in the codebook */ + int dim) /* (i) the dimension of all vectors */ + { + int i, j; + int pos, minindex; + float dist, tmp, mindist; + + pos = 0; + mindist = ilbc_constants.DOUBLE_MAX; + minindex = 0; + for (j = 0; j < n_cb; j++) { + dist = X[X_idx] - CB[pos+CB_idx]; + dist *= dist; + for (i = 1; i < dim; i++) { + tmp = X[i+X_idx] - CB[pos + i + CB_idx]; + dist += tmp*tmp; + } + + if (dist < mindist) { + mindist = dist; + minindex = j; + } + pos += dim; + } + for (i = 0; i < dim; i++) { + Xq[i+Xq_idx] = CB[minindex*dim + i+CB_idx]; + } + index[index_idx] = minindex; + } + + /*----------------------------------------------------------------* + * split vector quantization + *---------------------------------------------------------------*/ + + public void SplitVQ( + float qX[], /* (o) the quantized vector */ + int qX_idx, + int index[], /* (o) a vector of indexes for all vector + codebooks in the split */ + int index_idx, + float X[], /* (i) the vector to quantize */ + int X_idx, + float CB[],/* (i) the quantizer codebook */ + int nsplit, /* the number of vector splits */ + int dim[], /* the dimension of X and qX */ + int cbsize[]) /* the number of vectors in the codebook */ + { + int cb_pos, X_pos, i; + + cb_pos = 0; + X_pos = 0; + for (i = 0; i < nsplit; i++) { + vq(qX, X_pos + qX_idx, index, i + index_idx, CB, cb_pos, X, X_pos + X_idx, cbsize[i], dim[i]); + X_pos += dim[i]; + cb_pos += dim[i] * cbsize[i]; + } + } + + /*----------------------------------------------------------------* + * scalar quantization + *---------------------------------------------------------------*/ + + public float sort_sq( /* on renvoie xq et on modifie index par effet de bord */ + // float *xq, /* (o) the quantized value */ + int index[], /* (o) the quantization index */ + int index_idx, + float x, /* (i) the value to quantize */ + float cb[],/* (i) the quantization codebook */ + int cb_size) /* (i) the size of the quantization codebook */ + { + int i; + float xq; + + if (x <= cb[0]) { + // *index = 0; + index[index_idx] = 0; + xq = cb[0]; + } else { + i = 0; + while ((x > cb[i]) && i < cb_size - 1) { + i++; + } + + if (x > ((cb[i] + cb[i - 1])/2)) { + index[index_idx] = i; + xq = cb[i]; + } else { + index[index_idx] = i - 1; + xq = cb[i - 1]; + } + } + return xq; + } + + /*---------------------------------------------------------------* + * Classification of subframes to localize start state + *--------------------------------------------------------------*/ + + int FrameClassify( /* index to the max-energy sub-frame */ + float residual[]) /* (i) lpc residual signal */ + { + float max_ssqEn; + float [] fssqEn = new float[ilbc_constants.NSUB_MAX]; + float [] bssqEn = new float[ilbc_constants.NSUB_MAX]; + int pp; + int n, l, max_ssqEn_n; +// float [] ssqEn_win[NSUB_MAX-1]={(float)0.8,(float)0.9, + + float [] ssqEn_win = { (float)0.8, + (float)0.9, + (float)1.0f, + (float)0.9, + (float)0.8 }; + + float [] sampEn_win = { (float)1.0f/(float)6.0, + (float)2.0f/(float)6.0, + (float)3.0f/(float)6.0, + (float)4.0f/(float)6.0, + (float)5.0f/(float)6.0 }; + + /* init the front and back energies to zero */ + + for (int li = 0; li < ilbc_constants.NSUB_MAX; li++) + fssqEn[li] = 0.0f; + // memset(fssqEn, 0, NSUB_MAX*sizeof(float)); + for (int li = 0; li < ilbc_constants.NSUB_MAX; li++) + bssqEn[li] = 0.0f; + // memset(bssqEn, 0, NSUB_MAX*sizeof(float)); + + /* Calculate front of first seqence */ + + n=0; + // pp=residual; + pp = 0; + for (l=0; l<5; l++) { + fssqEn[n] += sampEn_win[l] * (residual[pp]) * (residual[pp]); + pp++; + } + for (l=5; l<ilbc_constants.SUBL; l++) { + fssqEn[n] += (residual[pp]) * (residual[pp]); + pp++; + } + + /* Calculate front and back of all middle sequences */ + + for (n=1; n < this.ULP_inst.nsub - 1; n++) { + // pp=residual+n*SUBL; + pp = n * ilbc_constants.SUBL; + for (l=0; l < 5; l++) { + fssqEn[n] += sampEn_win[l] * (residual[pp]) * (residual[pp]); + bssqEn[n] += (residual[pp]) * (residual[pp]); + pp++; + } + for (l=5; l<ilbc_constants.SUBL-5; l++) { + fssqEn[n] += (residual[pp]) * (residual[pp]); + bssqEn[n] += (residual[pp]) * (residual[pp]); + pp++; + } + for (l=ilbc_constants.SUBL-5; l<ilbc_constants.SUBL; l++) { + fssqEn[n] += (residual[pp]) * (residual[pp]); + bssqEn[n] += sampEn_win[ilbc_constants.SUBL-l-1] * (residual[pp]) * (residual[pp]); + pp++; + } + } + + /* Calculate back of last seqence */ + + n=this.ULP_inst.nsub-1; + pp=n*ilbc_constants.SUBL; + for (l=0; l < ilbc_constants.SUBL-5; l++) { + bssqEn[n] += (residual[pp]) * (residual[pp]); + pp++; + } + for (l=ilbc_constants.SUBL-5; l<ilbc_constants.SUBL; l++) { + bssqEn[n] += sampEn_win[ilbc_constants.SUBL-l-1] * (residual[pp]) * (residual[pp]); + pp++; + } + + /* find the index to the weighted 80 sample with + most energy */ + + if (this.ULP_inst.mode==20) + l=1; + else + l=0; + + max_ssqEn=(fssqEn[0]+bssqEn[1])*ssqEn_win[l]; + max_ssqEn_n=1; + for (n=2; n< this.ULP_inst.nsub; n++) { + l++; + if ((fssqEn[n-1]+bssqEn[n])*ssqEn_win[l] > max_ssqEn) { + max_ssqEn=(fssqEn[n-1]+bssqEn[n]) * + ssqEn_win[l]; + max_ssqEn_n=n; + } + } + + return max_ssqEn_n; + } + + /* from anaFilter.c, perform LP analysis filtering */ + private void anaFilter(float In[], int in_idx, float a[], int a_idx, int len, float Out[], int out_idx, float mem[]) + { + int i, j; + int po, pi, pm, pa; + + po = out_idx; + + /* Filter first part using memory from past */ + + for (i = 0; i < ilbc_constants.LPC_FILTERORDER; i++) { + pi = in_idx + i; + pm = ilbc_constants.LPC_FILTERORDER - 1; + pa = a_idx; + Out[po] = 0.0f; + + for (j=0; j<=i; j++) { + Out[po] += a[pa] * In[pi]; + pa++; + pi--; + } + for (j=i+1; j < ilbc_constants.LPC_FILTERORDER+1; j++) { + Out[po] += a[pa] * mem[pm]; + pa++; + pm--; + } + po++; + } + + /* Filter last part where the state is entirely + in the input vector */ + + for (i = ilbc_constants.LPC_FILTERORDER; i<len; i++) { + pi = in_idx + i; + pa = a_idx; + Out[po] = 0.0f; + for (j = 0; j < ilbc_constants.LPC_FILTERORDER+1; j++) { + Out[po] += a[pa] * In[pi]; + pa++; + pi--; + } + po++; + } + + /* Update state vector */ + + System.arraycopy(In, in_idx + len - ilbc_constants.LPC_FILTERORDER, mem, 0, ilbc_constants.LPC_FILTERORDER); + } + + /*----------------------------------------------------------------* + * Construct an additional codebook vector by filtering the + * initial codebook buffer. This vector is then used to expand + * the codebook with an additional section. + *---------------------------------------------------------------*/ + + private void filteredCBvecs(float cbvectors[], float mem[], int mem_idx, int lMem) + { + int i, j, k; + int pp, pp1; + float tempbuff2[]; + int pos; + + tempbuff2 = new float [ilbc_constants.CB_MEML+ilbc_constants.CB_FILTERLEN]; + + for (i = 0; i < ilbc_constants.CB_HALFFILTERLEN; i++) + tempbuff2[i] = 0.0f; + System.arraycopy(mem, mem_idx, tempbuff2, ilbc_constants.CB_HALFFILTERLEN - 1, lMem); + for (i = lMem + ilbc_constants.CB_HALFFILTERLEN - 1; i < lMem + ilbc_constants.CB_FILTERLEN; i++) + tempbuff2[i] = 0.0f; + + /* Create codebook vector for higher section by filtering */ + + /* do filtering */ + pos=0; + for (i = 0; i < lMem; i++) + cbvectors[i] = 0; + for (k = 0; k < lMem; k++) { + // pp=&tempbuff2[k]; + pp = k; + // pp1=&cbfiltersTbl[CB_FILTERLEN-1]; + pp1 = ilbc_constants.CB_FILTERLEN - 1; + for (j = 0;j < ilbc_constants.CB_FILTERLEN;j++) { + cbvectors[pos] += tempbuff2[pp] * ilbc_constants.cbfiltersTbl[pp1]; + pp++; + pp1--; + } + pos++; + } + } + + /*----------------------------------------------------------------* + * Search the augmented part of the codebook to find the best + * measure. + *----------------------------------------------------------------*/ + + private void searchAugmentedCB( + int low, /* (i) Start index for the search */ + int high, /* (i) End index for the search */ + int stage, /* (i) Current stage */ + int startIndex, /* (i) Codebook index for the first + aug vector */ + float target[], /* (i) Target vector for encoding */ + float buffer[], /* (i) Pointer to the end of the buffer for + augmented codebook construction */ + int buffer_idx, + float max_measure[], /* (i/o) Currently maximum measure */ + int best_index[],/* (o) Currently the best index */ + float gain[], /* (o) Currently the best gain */ + float energy[], /* (o) Energy of augmented codebook + vectors */ + float invenergy[]/* (o) Inv energy of augmented codebook + vectors */ + ) + { + int icount, ilow, j, tmpIndex; + int pp, ppo, ppi, ppe; + float crossDot, alfa; + float weighted, measure, nrjRecursive; + float ftmp; + + /* Compute the energy for the first (low-5) + noninterpolated samples */ + + // for (pp = 0; pp < buffer.length; pp++) + // System.out.println("buffer[" + (pp - buffer_idx) + "] = " + buffer[pp]); + + nrjRecursive = (float) 0.0f; + // pp = buffer - low + 1; + pp = 1 - low + buffer_idx; + for (j=0; j<(low-5); j++) { + nrjRecursive += ( buffer[pp] * buffer[pp] ); + pp++; + } + ppe = buffer_idx - low; + + // System.out.println("energie recursive " + nrjRecursive); + + for (icount=low; icount<=high; icount++) { + + /* Index of the codebook vector used for retrieving + energy values */ + tmpIndex = startIndex+icount-20; + + ilow = icount-4; + + /* Update the energy recursively to save complexity */ + nrjRecursive = nrjRecursive + buffer[ppe] * buffer[ppe]; + ppe--; + energy[tmpIndex] = nrjRecursive; + + /* Compute cross dot product for the first (low-5) + samples */ + + crossDot = (float) 0.0f; + pp = buffer_idx - icount; + for (j = 0; j < ilow; j++) { + crossDot += target[j]*buffer[pp]; + pp++; + } + + /* interpolation */ + alfa = (float) 0.2; + ppo = buffer_idx - 4; + ppi = buffer_idx - icount - 4; + for (j=ilow; j<icount; j++) { + weighted = ((float)1.0f-alfa)*(buffer[ppo])+alfa*(buffer[ppi]); + ppo++; + ppi++; + energy[tmpIndex] += weighted*weighted; + crossDot += target[j]*weighted; + alfa += (float)0.2; + } + + /* Compute energy and cross dot product for the + remaining samples */ + pp = buffer_idx - icount; + for (j=icount; j < ilbc_constants.SUBL; j++) { + energy[tmpIndex] += buffer[pp] * buffer[pp]; + crossDot += target[j]*buffer[pp]; + pp++; + } + + if (energy[tmpIndex]>0.0f) { + invenergy[tmpIndex]=(float)1.0f/(energy[tmpIndex] + ilbc_constants.EPS); + } else { + invenergy[tmpIndex] = (float) 0.0f; + } + + if (stage==0) { + measure = (float)-10000000.0f; + + if (crossDot > 0.0f) { + measure = crossDot*crossDot*invenergy[tmpIndex]; + } + } + else { + measure = crossDot*crossDot*invenergy[tmpIndex]; + } + + /* check if measure is better */ + ftmp = crossDot*invenergy[tmpIndex]; + + // System.out.println("on compare " + measure + " et " + max_measure[0]); + // System.out.println("ainsi que " + Math.abs(ftmp) + " et " + ilbc_constants.CB_MAXGAIN); + + if ((measure>max_measure[0]) && ((float)Math.abs(ftmp) < ilbc_constants.CB_MAXGAIN)) { + // System.out.println("new best index at " + tmpIndex + ", where icount = " + icount); + best_index[0] = tmpIndex; + max_measure[0] = measure; + gain[0] = ftmp; + } + } + } + + /*----------------------------------------------------------------* + * Recreate a specific codebook vector from the augmented part. + * + *----------------------------------------------------------------*/ + + private void createAugmentedVec(int index, float buffer[], int buffer_idx, float cbVec[]) + { + int ilow, j; + int pp, ppo, ppi; + float alfa, alfa1, weighted; + + ilow = index - 5; + + /* copy the first noninterpolated part */ + + pp = buffer_idx - index; + System.arraycopy(buffer, pp, cbVec, 0, index); + // memcpy(cbVec,pp,sizeof(float)*index); + + /* interpolation */ + + alfa1 = (float)0.2; + alfa = 0.0f; + // ppo = buffer-5; + ppo = buffer_idx - 5; + // ppi = buffer-index-5; + ppi = buffer_idx - index - 5; + for (j=ilow; j<index; j++) { + // weighted = ((float)1.0f-alfa)*(*ppo)+alfa*(*ppi); + weighted = (1.0f - alfa) * buffer[ppo] + alfa * buffer[ppi]; + ppo++; + ppi++; + cbVec[j] = weighted; + alfa += alfa1; + } + + /* copy the second noninterpolated part */ + + // pp = buffer - index; + pp = buffer_idx - index; + // memcpy(cbVec+index,pp,sizeof(float)*(SUBL-index)); + System.arraycopy(buffer, pp, cbVec, index, ilbc_constants.SUBL - index); + } + + + + public ilbc_encoder(int init_mode) throws Error + { + + mode = init_mode; + + if ( (mode == 30) || (mode == 20) ) + { + ULP_inst = new ilbc_ulp(mode); + } + else + { + throw(new Error("invalid mode")); + } + + anaMem = new float[ilbc_constants.LPC_FILTERORDER]; + lsfold = new float[ilbc_constants.LPC_FILTERORDER]; + lsfdeqold = new float[ilbc_constants.LPC_FILTERORDER]; + lpc_buffer = new float[ilbc_constants.LPC_LOOKBACK + ilbc_constants.BLOCKL_MAX]; + hpimem = new float[4]; + + for (int li = 0; li < anaMem.length; li++) + anaMem[li] = 0.0f; + + System.arraycopy(ilbc_constants.lsfmeanTbl, 0, this.lsfdeqold, 0, + ilbc_constants.LPC_FILTERORDER); +// for (int li = 0; li < lsfold.length; li++) +// lsfold[li] = 0.0f; + + System.arraycopy(ilbc_constants.lsfmeanTbl, 0, this.lsfold, 0, + ilbc_constants.LPC_FILTERORDER); +// for (int li = 0; li < lsfdeqold.length; li++) +// lsfdeqold[li] = 0.0f; + + for (int li = 0; li < lpc_buffer.length; li++) + lpc_buffer[li] = 0.0f; + + for (int li = 0; li < hpimem.length; li++) + hpimem[li] = 0.0f; + + // 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); + } + + // public int encode(short encoded_data[], short data[]) + // { + // for (int i = 0; i < encoded_data.length; i ++) { + // data[i%data.length] = encoded_data[i]; + // } + + // if (mode == 20) + // return ilbc_constants.BLOCKL_20MS; + // else + // return ilbc_constants.BLOCKL_30MS; + // } + public short encode(short encoded_data[], short data[]) + { + float block[] = new float [this.ULP_inst.blockl]; + bitstream en_data = new bitstream(this.ULP_inst.no_of_bytes * 2); + // char en_data[] = new char [this.ULP_inst.no_of_bytes]; + int k; + + /* convert signal to float */ + + for (k=0; k<this.ULP_inst.blockl; k++) + block[k] = (float) data[k]; + + // for (int li = 0; li < block.length; li++) + // System.out.println("block " + li + " : " + block[li]); + + /* do the actual encoding */ + + iLBC_encode(en_data, block); + + for (k=0; k < encoded_data.length; k++) + encoded_data[k] = (short) (((en_data.buffer[2*k] << 8) & 0xff00) | ( ((short) en_data.buffer[2*k+1]) & 0x00ff)); + + return ((short) this.ULP_inst.no_of_bytes); + + } + + public void iLBC_encode( + bitstream bytes, /* (o) encoded data bits iLBC */ + float block[]) /* (o) speech vector to encode */ + { + int start; + int [] idxForMax = new int[1]; + int n, k, meml_gotten, Nfor, Nback, i, pos; + // unsigned char *pbytes; + int pbytes; + int diff, start_pos, state_first; + float en1, en2; + int index, ulp; + // int [] firstpart = new int[1]; + int firstpart; + int subcount, subframe; + + float [] data = new float[ilbc_constants.BLOCKL_MAX]; + float [] residual = new float[ilbc_constants.BLOCKL_MAX]; + float [] reverseResidual = new float[ilbc_constants.BLOCKL_MAX]; + + int [] idxVec = new int[ilbc_constants.STATE_LEN]; + float [] reverseDecresidual = new float[ilbc_constants.BLOCKL_MAX]; + float [] mem = new float[ilbc_constants.CB_MEML]; + + int [] gain_index = new int[ilbc_constants.CB_NSTAGES*ilbc_constants.NASUB_MAX]; + int [] extra_gain_index = new int[ilbc_constants.CB_NSTAGES]; + int [] cb_index = new int[ilbc_constants.CB_NSTAGES*ilbc_constants.NASUB_MAX]; + int [] extra_cb_index = new int[ilbc_constants.CB_NSTAGES]; + int [] lsf_i = new int[ilbc_constants.LSF_NSPLIT*ilbc_constants.LPC_N_MAX]; + + float [] weightState = new float[ilbc_constants.LPC_FILTERORDER]; + float [] syntdenum = new float[ilbc_constants.NSUB_MAX*(ilbc_constants.LPC_FILTERORDER+1)]; + float [] weightdenum = new float[ilbc_constants.NSUB_MAX*(ilbc_constants.LPC_FILTERORDER+1)]; + float [] decresidual = new float[ilbc_constants.BLOCKL_MAX]; + + bitpack pack; + + /* high pass filtering of input signal if such is not done + prior to calling this function */ + + // System.out.println("Data prior to hpinput call"); + // for (int li = 0; li < data.length; li++) + // System.out.println("index : " + li + " and value " + data[li]); + // System.out.println("Mem prior to hpinput call"); + // for (int li = 0; li < this.hpimem.length; li++) + // System.out.println("index : " + li + " and value " + this.hpimem[li]); + hpInput(block, this.ULP_inst.blockl, data, this.hpimem); + // System.out.println("Data after hpinput call"); + // for (int li = 0; li < data.length; li++) + // System.out.println("index : " + li + " and value " + data[li]); + // System.out.println("Mem after hpinput call"); + // for (int li = 0; li < this.hpimem.length; li++) + // System.out.println("index : " + li + " and value " + this.hpimem[li]); + + + /* otherwise simply copy */ + + /*memcpy(data,block,iLBCenc_inst->blockl*sizeof(float));*/ + + /* LPC of hp filtered input data */ + + LPCencode(syntdenum, weightdenum, lsf_i, data); + + // for (int li = 0; li < ilbc_constants.NSUB_MAX*(ilbc_constants.LPC_FILTERORDER+1); li++) + // System.out.println("postLPC n-" + li + " is worth " + syntdenum[li] + ", " + weightdenum[li]); + + /* inverse filter to get residual */ + + for (n = 0; n < this.ULP_inst.nsub; n++) { + anaFilter(data, n*ilbc_constants.SUBL, syntdenum, n*(ilbc_constants.LPC_FILTERORDER+1), + ilbc_constants.SUBL, residual, n*ilbc_constants.SUBL, this.anaMem); + } + + // for (int li = 0; li < ilbc_constants.BLOCKL_MAX; li++) + // System.out.println("block residual n-" + li + " is worth " + residual[li]); + + /* find state location */ + + start = FrameClassify(residual); + + /* check if state should be in first or last part of the + two subframes */ + + diff = ilbc_constants.STATE_LEN - this.ULP_inst.state_short_len; + en1 = 0; + index = (start-1)*ilbc_constants.SUBL; + for (i = 0; i < this.ULP_inst.state_short_len; i++) { + en1 += residual[index+i]*residual[index+i]; + } + en2 = 0; + index = (start-1)*ilbc_constants.SUBL+diff; + for (i = 0; i < this.ULP_inst.state_short_len; i++) { + en2 += residual[index+i]*residual[index+i]; + } + + + if (en1 > en2) { + state_first = 1; + start_pos = (start-1)*ilbc_constants.SUBL; + } else { + state_first = 0; + start_pos = (start-1)*ilbc_constants.SUBL + diff; + } + + /* scalar quantization of state */ + + StateSearchW(residual, start_pos, + syntdenum, (start-1)*(ilbc_constants.LPC_FILTERORDER+1), + weightdenum, (start-1)*(ilbc_constants.LPC_FILTERORDER+1), + idxForMax, idxVec, this.ULP_inst.state_short_len, state_first); + + ilbc_common.StateConstructW(idxForMax[0], idxVec, + syntdenum, (start-1)*(ilbc_constants.LPC_FILTERORDER+1), + decresidual, start_pos, this.ULP_inst.state_short_len); + + /* predictive quantization in state */ + + if (state_first != 0) { /* put adaptive part in the end */ + + /* setup memory */ + for (int li = 0; li < ilbc_constants.CB_MEML-this.ULP_inst.state_short_len; li++) + mem[li] = 0.0f; + System.arraycopy(decresidual, start_pos, + mem, ilbc_constants.CB_MEML-this.ULP_inst.state_short_len, + this.ULP_inst.state_short_len); + // memcpy(mem+ilbc_constants.CB_MEML-this.ULP_inst.state_short_len, + // decresidual+start_pos, + // this.ULP_inst.state_short_len*sizeof(float)); + for (int li = 0; li < ilbc_constants.LPC_FILTERORDER; li++) + weightState[li] = 0.0f; + // memset(weightState, 0, ilbc_constants.LPC_FILTERORDER*sizeof(float)); + + /* encode sub-frames */ + + iCBSearch(extra_cb_index, 0, extra_gain_index, 0, + residual, start_pos+this.ULP_inst.state_short_len, + mem, ilbc_constants.CB_MEML-ilbc_constants.stMemLTbl, + ilbc_constants.stMemLTbl, diff, ilbc_constants.CB_NSTAGES, + weightdenum, start*(ilbc_constants.LPC_FILTERORDER+1), + weightState, 0); + + /* construct decoded vector */ + + ilbc_common.iCBConstruct(decresidual, start_pos+this.ULP_inst.state_short_len, + extra_cb_index, 0, extra_gain_index, 0, + mem, ilbc_constants.CB_MEML-ilbc_constants.stMemLTbl, + ilbc_constants.stMemLTbl, diff, ilbc_constants.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)*ilbc_constants.SUBL-1 + -(k+this.ULP_inst.state_short_len)]; + } + + /* setup memory */ + + meml_gotten = this.ULP_inst.state_short_len; + for (k=0; k<meml_gotten; k++) { + mem[ilbc_constants.CB_MEML-1-k] = decresidual[start_pos + k]; + } + for (int li = 0; li < (ilbc_constants.CB_MEML - k); li++) + mem[li] = 0.0f; + // memset(mem, 0, (ilbc_constants.CB_MEML-k)*sizeof(float)); + for (int li = 0; li < ilbc_constants.LPC_FILTERORDER; li++) + weightState[li] = 0.0f; + // memset(weightState, 0, ilbc_constants.LPC_FILTERORDER*sizeof(float)); + + /* encode sub-frames */ + + iCBSearch(extra_cb_index, 0, extra_gain_index, 0, + reverseResidual, 0, + mem, ilbc_constants.CB_MEML-ilbc_constants.stMemLTbl, ilbc_constants.stMemLTbl, + diff, ilbc_constants.CB_NSTAGES, + weightdenum, (start-1)*(ilbc_constants.LPC_FILTERORDER+1), + weightState, 0); + + /* construct decoded vector */ + + ilbc_common.iCBConstruct(reverseDecresidual, 0, extra_cb_index, 0, + extra_gain_index, 0, mem, + ilbc_constants.CB_MEML - ilbc_constants.stMemLTbl, + ilbc_constants.stMemLTbl, diff, ilbc_constants.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 = this.ULP_inst.nsub-start-1; + + + if ( Nfor > 0 ) { + + /* setup memory */ + + for (int li = 0; li < (ilbc_constants.CB_MEML-ilbc_constants.STATE_LEN); li++) + mem[li] = 0.0f; + // memset(mem, 0, (ilbc_constants.CB_MEML-ilbc_constants.STATE_LEN)*sizeof(float)); + System.arraycopy(decresidual, (start-1)*ilbc_constants.SUBL, + mem, ilbc_constants.CB_MEML-ilbc_constants.STATE_LEN, + ilbc_constants.STATE_LEN); + // memcpy(mem+ilbc_constants.CB_MEML-ilbc_constants.STATE_LEN, + // decresidual+(start-1)*ilbc_constants.SUBL, + // ilbc_constants.STATE_LEN*sizeof(float)); + for (int li = 0; li < ilbc_constants.LPC_FILTERORDER; li++) + weightState[li] = 0.0f; + // memset(weightState, 0, ilbc_constants.LPC_FILTERORDER*sizeof(float)); + + /* loop over sub-frames to encode */ + + for (subframe=0; subframe<Nfor; subframe++) { + + /* encode sub-frame */ + + iCBSearch(cb_index, subcount*ilbc_constants.CB_NSTAGES, + gain_index, subcount*ilbc_constants.CB_NSTAGES, + residual, (start+1+subframe)*ilbc_constants.SUBL, + mem, ilbc_constants.CB_MEML-ilbc_constants.memLfTbl[subcount], + ilbc_constants.memLfTbl[subcount], ilbc_constants.SUBL, ilbc_constants.CB_NSTAGES, + weightdenum, (start+1+subframe)*(ilbc_constants.LPC_FILTERORDER+1), + weightState, subcount+1); + + /* construct decoded vector */ + + ilbc_common.iCBConstruct(decresidual, (start+1+subframe)*ilbc_constants.SUBL, + cb_index, subcount*ilbc_constants.CB_NSTAGES, + gain_index, subcount*ilbc_constants.CB_NSTAGES, + mem, ilbc_constants.CB_MEML-ilbc_constants.memLfTbl[subcount], + ilbc_constants.memLfTbl[subcount], ilbc_constants.SUBL, + ilbc_constants.CB_NSTAGES); + + /* update memory */ + + System.arraycopy(mem, ilbc_constants.SUBL, + mem, 0, + (ilbc_constants.CB_MEML-ilbc_constants.SUBL)); + // memcpy(mem, mem+ilbc_constants.SUBL, (ilbc_constants.CB_MEML-ilbc_constants.SUBL)*sizeof(float)); + System.arraycopy(decresidual, (start+1+subframe)*ilbc_constants.SUBL, + mem, ilbc_constants.CB_MEML-ilbc_constants.SUBL, + ilbc_constants.SUBL); + // memcpy(mem+ilbc_constants.CB_MEML-ilbc_constants.SUBL, + // &decresidual[(start+1+subframe)*ilbc_constants.SUBL], + // ilbc_constants.SUBL*sizeof(float)); + for (int li = 0; li < ilbc_constants.LPC_FILTERORDER; li++) + weightState[li] = 0.0f; + // memset(weightState, 0, ilbc_constants.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<ilbc_constants.SUBL; k++) { + reverseResidual[n*ilbc_constants.SUBL+k] = + residual[(start-1)*ilbc_constants.SUBL-1-n*ilbc_constants.SUBL-k]; + reverseDecresidual[n*ilbc_constants.SUBL+k] = + decresidual[(start-1)*ilbc_constants.SUBL-1-n*ilbc_constants.SUBL-k]; + } + } + + /* setup memory */ + + meml_gotten = ilbc_constants.SUBL*(this.ULP_inst.nsub+1-start); + + + if ( meml_gotten > ilbc_constants.CB_MEML ) { + meml_gotten=ilbc_constants.CB_MEML; + } + for (k=0; k<meml_gotten; k++) { + mem[ilbc_constants.CB_MEML-1-k] = decresidual[(start-1)*ilbc_constants.SUBL + k]; + } + for (int li = 0; li < (ilbc_constants.CB_MEML - k); li++) + mem[li] = 0.0f; + // memset(mem, 0, (ilbc_constants.CB_MEML-k)*sizeof(float)); + for (int li = 0; li < ilbc_constants.LPC_FILTERORDER; li++) + weightState[li] = 0.0f; + // memset(weightState, 0, ilbc_constants.LPC_FILTERORDER*sizeof(float)); + + /* loop over sub-frames to encode */ + + for (subframe=0; subframe<Nback; subframe++) { + + /* encode sub-frame */ + + iCBSearch(cb_index, subcount*ilbc_constants.CB_NSTAGES, + gain_index, subcount*ilbc_constants.CB_NSTAGES, + reverseResidual, subframe*ilbc_constants.SUBL, + mem, ilbc_constants.CB_MEML-ilbc_constants.memLfTbl[subcount], + ilbc_constants.memLfTbl[subcount], ilbc_constants.SUBL, ilbc_constants.CB_NSTAGES, + weightdenum, (start-2-subframe)*(ilbc_constants.LPC_FILTERORDER+1), + weightState, subcount+1); + + /* construct decoded vector */ + + ilbc_common.iCBConstruct(reverseDecresidual, subframe*ilbc_constants.SUBL, + cb_index, subcount*ilbc_constants.CB_NSTAGES, + gain_index, subcount*ilbc_constants.CB_NSTAGES, + mem, ilbc_constants.CB_MEML-ilbc_constants.memLfTbl[subcount], + ilbc_constants.memLfTbl[subcount], ilbc_constants.SUBL, + ilbc_constants.CB_NSTAGES); + + /* update memory */ + + System.arraycopy(mem, ilbc_constants.SUBL, + mem, 0, + (ilbc_constants.CB_MEML-ilbc_constants.SUBL)); + // memcpy(mem, mem+ilbc_constants.SUBL, (ilbc_constants.CB_MEML-ilbc_constants.SUBL)*sizeof(float)); + System.arraycopy(reverseDecresidual, subframe*ilbc_constants.SUBL, + mem, ilbc_constants.CB_MEML-ilbc_constants.SUBL, + ilbc_constants.SUBL); + // memcpy(mem+ilbc_constants.CB_MEML-ilbc_constants.SUBL, + // &reverseDecresidual[subframe*ilbc_constants.SUBL], + // ilbc_constants.SUBL*sizeof(float)); + for (int li = 0; li < ilbc_constants.LPC_FILTERORDER; li++) + weightState[li] = 0.0f; + // memset(weightState, 0, ilbc_constants.LPC_FILTERORDER*sizeof(float)); + + subcount++; + + } + + /* get decoded residual from reversed vector */ + + for (i=0; i<ilbc_constants.SUBL*Nback; i++) { + decresidual[ilbc_constants.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++) { + + int [] psarray = new int[1]; + /* LSF */ + // System.out.println("ULP Class " + ulp); + for (k=0; k<ilbc_constants.LSF_NSPLIT*this.ULP_inst.lpc_n; k++) { + //System.out.println("LSF " + k); + pack = bytes.packsplit(lsf_i[k], + this.ULP_inst.lsf_bits[k][ulp], + this.ULP_inst.lsf_bits[k][ulp]+ + this.ULP_inst.lsf_bits[k][ulp+1]+ + this.ULP_inst.lsf_bits[k][ulp+2]); + firstpart = pack.get_firstpart(); + lsf_i[k] = pack.get_rest(); + bytes.dopack(firstpart, this.ULP_inst.lsf_bits[k][ulp]); + } + + /* Start block info */ + + // System.out.println("start bits"); + + pack = bytes.packsplit(start, + this.ULP_inst.start_bits[ulp], + this.ULP_inst.start_bits[ulp]+ + this.ULP_inst.start_bits[ulp+1]+ + this.ULP_inst.start_bits[ulp+2]); + firstpart = pack.get_firstpart(); + start = pack.get_rest(); + bytes.dopack(firstpart, this.ULP_inst.start_bits[ulp]); + + // System.out.println("startfirst bits"); + + pack = bytes.packsplit(state_first, + this.ULP_inst.startfirst_bits[ulp], + this.ULP_inst.startfirst_bits[ulp]+ + this.ULP_inst.startfirst_bits[ulp+1]+ + this.ULP_inst.startfirst_bits[ulp+2]); + firstpart = pack.get_firstpart(); + state_first = pack.get_rest(); + bytes.dopack(firstpart, this.ULP_inst.startfirst_bits[ulp]); + + // System.out.println("scale bits"); + pack = bytes.packsplit(idxForMax[0], + this.ULP_inst.scale_bits[ulp], + this.ULP_inst.scale_bits[ulp]+ + this.ULP_inst.scale_bits[ulp+1]+ + this.ULP_inst.scale_bits[ulp+2]); + firstpart = pack.get_firstpart(); + idxForMax[0] = pack.get_rest(); + bytes.dopack(firstpart, this.ULP_inst.scale_bits[ulp]); + + // System.out.println("state bits"); + for (k=0; k<this.ULP_inst.state_short_len; k++) { + // System.out.println("state short len #" + k); + pack = bytes.packsplit(idxVec[k], + this.ULP_inst.state_bits[ulp], + this.ULP_inst.state_bits[ulp]+ + this.ULP_inst.state_bits[ulp+1]+ + this.ULP_inst.state_bits[ulp+2]); + firstpart = pack.get_firstpart(); + idxVec[k] = pack.get_rest(); + bytes.dopack(firstpart, this.ULP_inst.state_bits[ulp]); + } + + /* 23/22 (20ms/30ms) sample block */ + + // System.out.println("extra_cb_index"); + for (k=0;k<ilbc_constants.CB_NSTAGES;k++) { + pack = bytes.packsplit(extra_cb_index[k], + this.ULP_inst.extra_cb_index[k][ulp], + this.ULP_inst.extra_cb_index[k][ulp]+ + this.ULP_inst.extra_cb_index[k][ulp+1]+ + this.ULP_inst.extra_cb_index[k][ulp+2]); + firstpart = pack.get_firstpart(); + extra_cb_index[k] = pack.get_rest(); + bytes.dopack(firstpart, this.ULP_inst.extra_cb_index[k][ulp]); + } + + // System.out.println("extra_cb_gain"); + for (k=0;k<ilbc_constants.CB_NSTAGES;k++) { + pack = bytes.packsplit(extra_gain_index[k], + this.ULP_inst.extra_cb_gain[k][ulp], + this.ULP_inst.extra_cb_gain[k][ulp]+ + this.ULP_inst.extra_cb_gain[k][ulp+1]+ + this.ULP_inst.extra_cb_gain[k][ulp+2]); + firstpart = pack.get_firstpart(); + extra_gain_index[k] = pack.get_rest(); + // this.ULP_inst.extra_cb_gain[k][ulp] = pack.get_rest(); + bytes.dopack(firstpart, this.ULP_inst.extra_cb_gain[k][ulp]); + } + + /* The two/four (20ms/30ms) 40 sample sub-blocks */ + + // System.out.println("cb_index"); + + for (i=0; i<this.ULP_inst.nasub; i++) { + for (k=0; k<ilbc_constants.CB_NSTAGES; k++) { + pack = bytes.packsplit(cb_index[i*ilbc_constants.CB_NSTAGES+k], + this.ULP_inst.cb_index[i][k][ulp], + this.ULP_inst.cb_index[i][k][ulp]+ + this.ULP_inst.cb_index[i][k][ulp+1]+ + this.ULP_inst.cb_index[i][k][ulp+2]); + firstpart = pack.get_firstpart(); + cb_index[i*ilbc_constants.CB_NSTAGES+k] = pack.get_rest(); + bytes.dopack(firstpart, this.ULP_inst.cb_index[i][k][ulp]); + } + } + + // System.out.println("cb_gain"); + for (i=0; i<this.ULP_inst.nasub; i++) { + for (k=0; k<ilbc_constants.CB_NSTAGES; k++) { + pack = bytes.packsplit(gain_index[i*ilbc_constants.CB_NSTAGES+k], + this.ULP_inst.cb_gain[i][k][ulp], + this.ULP_inst.cb_gain[i][k][ulp]+ + this.ULP_inst.cb_gain[i][k][ulp+1]+ + this.ULP_inst.cb_gain[i][k][ulp+2]); + firstpart = pack.get_firstpart(); + gain_index[i*ilbc_constants.CB_NSTAGES+k] = pack.get_rest(); + bytes.dopack(firstpart, this.ULP_inst.cb_gain[i][k][ulp]); + } + } + } + + /* set the last bit to zero (otherwise the decoder + will treat it as a lost frame) */ + // System.out.println("final bit"); + bytes.dopack(0, 1); + } + +} + diff --git a/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/ilbc_ulp.java b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/ilbc_ulp.java new file mode 100644 index 0000000..39fa09a --- /dev/null +++ b/src/net/java/sip/communicator/impl/media/codec/audio/ilbc/ilbc_ulp.java @@ -0,0 +1,113 @@ +/* + * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client. + * + * Distributable under LGPL license. + * See terms of license at gnu.org. + */ +package net.java.sip.communicator.impl.media.codec.audio.ilbc; + +import java.lang.*; + +/** + * @author Jean Lorchat + */ +class ilbc_ulp { + + /* codec settings for encoder instance */ + + int mode; + + int blockl; + int nsub; + int nasub; + int lpc_n; + int no_of_bytes; + int no_of_words; + int state_short_len; + + int lsf_bits[][]; + int start_bits[]; + int startfirst_bits[]; + int scale_bits[]; + int state_bits[]; + int extra_cb_index[][]; + int extra_cb_gain[][]; + int cb_index[][][]; + int cb_gain[][][]; + + public ilbc_ulp(int init_mode) + { + mode = init_mode; + + if ( (mode != 20) && (mode != 30) ) + { + System.out.println("Unknown mode " + init_mode); + return; + } + + lsf_bits = new int[6][ilbc_constants.ULP_CLASSES+2]; + start_bits = new int[ilbc_constants.ULP_CLASSES+2]; + startfirst_bits = new int[ilbc_constants.ULP_CLASSES+2]; + scale_bits = new int[ilbc_constants.ULP_CLASSES+2]; + state_bits = new int[ilbc_constants.ULP_CLASSES+2]; + extra_cb_index = new int[ilbc_constants.CB_NSTAGES][ilbc_constants.ULP_CLASSES+2]; + extra_cb_gain = new int[ilbc_constants.CB_NSTAGES][ilbc_constants.ULP_CLASSES+2]; + cb_index = new int[ilbc_constants.NSUB_MAX][ilbc_constants.CB_NSTAGES][ilbc_constants.ULP_CLASSES+2]; + cb_gain = new int[ilbc_constants.NSUB_MAX][ilbc_constants.CB_NSTAGES][ilbc_constants.ULP_CLASSES+2]; + + if (mode == 20) + { + blockl = ilbc_constants.BLOCKL_20MS; + nsub = ilbc_constants.NSUB_20MS; + nasub = ilbc_constants.NASUB_20MS; + lpc_n = ilbc_constants.LPC_N_20MS; + no_of_bytes = ilbc_constants.NO_OF_BYTES_20MS; + no_of_words = ilbc_constants.NO_OF_WORDS_20MS; + state_short_len = ilbc_constants.STATE_SHORT_LEN_20MS; + /* ULP init */ + // iLBCenc_inst->ULP_inst=&ULP_20msTbl; + System.arraycopy(ilbc_constants.lsf_bits_20ms, 0, lsf_bits, 0, 6); + System.arraycopy(ilbc_constants.start_bits_20ms, 0, start_bits, 0, ilbc_constants.start_bits_20ms.length); + System.arraycopy(ilbc_constants.startfirst_bits_20ms, 0, startfirst_bits, 0, ilbc_constants.startfirst_bits_20ms.length); + System.arraycopy(ilbc_constants.scale_bits_20ms, 0, scale_bits, 0, ilbc_constants.scale_bits_20ms.length); + System.arraycopy(ilbc_constants.state_bits_20ms, 0, state_bits, 0, ilbc_constants.state_bits_20ms.length); + System.arraycopy(ilbc_constants.extra_cb_index_20ms, 0, extra_cb_index, 0, ilbc_constants.CB_NSTAGES); + System.arraycopy(ilbc_constants.extra_cb_gain_20ms, 0, extra_cb_gain, 0, ilbc_constants.CB_NSTAGES); + System.arraycopy(ilbc_constants.cb_index_20ms, 0, cb_index, 0, ilbc_constants.NSUB_20MS); + System.arraycopy(ilbc_constants.cb_gain_20ms, 0, cb_gain, 0, ilbc_constants.NSUB_20MS); + } + else if (mode == 30) + { + blockl = ilbc_constants.BLOCKL_30MS; + nsub = ilbc_constants.NSUB_30MS; + nasub = ilbc_constants.NASUB_30MS; + lpc_n = ilbc_constants.LPC_N_30MS; + no_of_bytes = ilbc_constants.NO_OF_BYTES_30MS; + no_of_words = ilbc_constants.NO_OF_WORDS_30MS; + state_short_len = ilbc_constants.STATE_SHORT_LEN_30MS; + /* ULP init */ + // ULP_inst=&ULP_30msTbl; + System.arraycopy(ilbc_constants.lsf_bits_30ms, 0, lsf_bits, 0, 6); + System.arraycopy(ilbc_constants.start_bits_30ms, 0, start_bits, 0, ilbc_constants.start_bits_30ms.length); + System.arraycopy(ilbc_constants.startfirst_bits_30ms, 0, startfirst_bits, 0, ilbc_constants.startfirst_bits_30ms.length); + System.arraycopy(ilbc_constants.scale_bits_30ms, 0, scale_bits, 0, ilbc_constants.scale_bits_30ms.length); + System.arraycopy(ilbc_constants.state_bits_30ms, 0, state_bits, 0, ilbc_constants.state_bits_30ms.length); + System.arraycopy(ilbc_constants.extra_cb_index_30ms, 0, extra_cb_index, 0, ilbc_constants.CB_NSTAGES); + System.arraycopy(ilbc_constants.extra_cb_gain_30ms, 0, extra_cb_gain, 0, ilbc_constants.CB_NSTAGES); + // System.out.println("nsubmax vaut: " + NSUB_MAX + " vs " + NSUB_30MS + ", alors que la taille de la table est: " + cb_index_30ms.length + " vs " + cb_index.length); + System.arraycopy(ilbc_constants.cb_index_30ms, 0, cb_index, 0, ilbc_constants.NSUB_30MS); + System.arraycopy(ilbc_constants.cb_gain_30ms, 0, cb_gain, 0, ilbc_constants.NSUB_30MS); + } + + // for (int i = 0; i < NSUB_MAX; i++) { + // for (int j = 0; j < CB_NSTAGES; j++) { + // for (int k = 0; k < ULP_CLASSES+2; k++) { + // System.out.print(" " + cb_gain[i][j][k]); + // } + // System.out.print(" | "); + // } + // System.out.println(""); + // } + } +} + |