From 81d1b2797aa3945c529d57f9ddf6179ec2b392a4 Mon Sep 17 00:00:00 2001
From: Benny Prijono <bennylp@teluu.com>
Date: Sat, 7 Apr 2007 12:47:34 +0000
Subject: Moved ilbc to third_party directory

git-svn-id: http://svn.pjsip.org/repos/pjproject/branches/split-3rd-party@1169 74dad513-b988-da41-8d7b-12977e46ad98
---
 pjmedia/src/pjmedia-codec/ilbc/enhancer.c | 701 ------------------------------
 1 file changed, 701 deletions(-)
 delete mode 100644 pjmedia/src/pjmedia-codec/ilbc/enhancer.c

(limited to 'pjmedia/src/pjmedia-codec/ilbc/enhancer.c')

diff --git a/pjmedia/src/pjmedia-codec/ilbc/enhancer.c b/pjmedia/src/pjmedia-codec/ilbc/enhancer.c
deleted file mode 100644
index dee13b03..00000000
--- a/pjmedia/src/pjmedia-codec/ilbc/enhancer.c
+++ /dev/null
@@ -1,701 +0,0 @@
-
-   /******************************************************************
-
-       iLBC Speech Coder ANSI-C Source Code
-
-       enhancer.c
-
-       Copyright (C) The Internet Society (2004).
-       All Rights Reserved.
-
-   ******************************************************************/
-
-   #include <math.h>
-   #include <string.h>
-   #include "iLBC_define.h"
-   #include "constants.h"
-   #include "filter.h"
-
-   /*----------------------------------------------------------------*
-    * 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
-    *---------------------------------------------------------------*/
-
-   void 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;
-
-       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;
-           }
-       }
-   }
-
-   /*----------------------------------------------------------------*
-    * compute cross correlation between sequences
-    *---------------------------------------------------------------*/
-
-   void mycorr1(
-       float* corr,    /* (o) correlation of seq1 and seq2 */
-       float* seq1,    /* (i) first sequence */
-       int dim1,           /* (i) dimension first seq1 */
-       const float *seq2,  /* (i) second sequence */
-       int dim2        /* (i) dimension seq2 */
-   ){
-       int i,j;
-
-       for (i=0; i<=dim1-dim2; i++) {
-           corr[i]=0.0;
-           for (j=0; j<dim2; j++) {
-               corr[i] += seq1[i+j] * seq2[j];
-           }
-       }
-   }
-
-   /*----------------------------------------------------------------*
-    * upsample finite array assuming zeros outside bounds
-    *---------------------------------------------------------------*/
-
-
-
-
-
-
-   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 i,j,k,q,filterlength,hfl2;
-       const float *polyp[ENH_UPS0]; /* pointers to
-                                        polyphase columns */
-       const float *pp;
-
-       /* define pointers for filter */
-
-       filterlength=2*hfl+1;
-
-       if ( filterlength > dim1 ) {
-           hfl2=(int) (dim1/2);
-           for (j=0; j<ENH_UPS0; j++) {
-               polyp[j]=polyphaserTbl+j*filterlength+hfl-hfl2;
-           }
-           hfl=hfl2;
-           filterlength=2*hfl+1;
-       }
-       else {
-           for (j=0; j<ENH_UPS0; j++) {
-               polyp[j]=polyphaserTbl+j*filterlength;
-           }
-       }
-
-       /* filtering: filter overhangs left side of sequence */
-
-       pu=useq1;
-       for (i=hfl; i<filterlength; i++) {
-           for (j=0; j<ENH_UPS0; j++) {
-               *pu=0.0;
-               pp = polyp[j];
-               ps = seq1+i;
-               for (k=0; k<=i; k++) {
-                   *pu += *ps-- * *pp++;
-               }
-               pu++;
-           }
-       }
-
-       /* filtering: simple convolution=inner products */
-
-       for (i=filterlength; i<dim1; i++) {
-
-
-
-
-
-           for (j=0;j<ENH_UPS0; j++){
-               *pu=0.0;
-               pp = polyp[j];
-               ps = seq1+i;
-               for (k=0; k<filterlength; k++) {
-                   *pu += *ps-- * *pp++;
-               }
-               pu++;
-           }
-       }
-
-       /* filtering: filter overhangs right side of sequence */
-
-       for (q=1; q<=hfl; q++) {
-           for (j=0; j<ENH_UPS0; j++) {
-               *pu=0.0;
-               pp = polyp[j]+q;
-               ps = seq1+dim1-1;
-               for (k=0; k<filterlength-q; k++) {
-                   *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
-    *---------------------------------------------------------------*/
-
-   void refiner(
-       float *seg,         /* (o) segment array */
-       float *updStartPos, /* (o) updated start point */
-       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[ENH_VECTL],corrVec[ENH_CORRDIM],maxv;
-       float corrVecUps[ENH_CORRDIM*ENH_UPS0];
-
-       (void)period;
-
-
-
-       /* defining array bounds */
-
-       estSegPosRounded=(int)(estSegPos - 0.5);
-
-       searchSegStartPos=estSegPosRounded-ENH_SLOP;
-
-       if (searchSegStartPos<0) {
-           searchSegStartPos=0;
-       }
-       searchSegEndPos=estSegPosRounded+ENH_SLOP;
-
-       if (searchSegEndPos+ENH_BLOCKL >= idatal) {
-           searchSegEndPos=idatal-ENH_BLOCKL-1;
-       }
-       corrdim=searchSegEndPos-searchSegStartPos+1;
-
-       /* compute upsampled correlation (corr33) and find
-          location of max */
-
-       mycorr1(corrVec,idata+searchSegStartPos,
-           corrdim+ENH_BLOCKL-1,idata+centerStartPos,ENH_BLOCKL);
-       enh_upsample(corrVecUps,corrVec,corrdim,ENH_FL0);
-       tloc=0; maxv=corrVecUps[0];
-       for (i=1; i<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)ENH_UPS0+(float)1.0;
-       tloc2=(int)(tloc/ENH_UPS0);
-
-       if (tloc>tloc2*ENH_UPS0) {
-           tloc2++;
-       }
-       st=searchSegStartPos+tloc2-ENH_FL0;
-
-       if (st<0) {
-           memset(vect,0,-st*sizeof(float));
-           memcpy(&vect[-st],idata, (ENH_VECTL+st)*sizeof(float));
-       }
-       else {
-
-
-
-
-
-           en=st+ENH_VECTL;
-
-           if (en>idatal) {
-               memcpy(vect, &idata[st],
-                   (ENH_VECTL-(en-idatal))*sizeof(float));
-               memset(&vect[ENH_VECTL-(en-idatal)], 0,
-                   (en-idatal)*sizeof(float));
-           }
-           else {
-               memcpy(vect, &idata[st], ENH_VECTL*sizeof(float));
-           }
-       }
-       fraction=tloc2*ENH_UPS0-tloc;
-
-       /* compute the segment (this is actually a convolution) */
-
-       mycorr1(seg,vect,ENH_VECTL,polyphaserTbl+(2*ENH_FL0+1)*fraction,
-           2*ENH_FL0+1);
-   }
-
-   /*----------------------------------------------------------------*
-    * find the smoothed output data
-    *---------------------------------------------------------------*/
-
-   void smath(
-       float *odata,   /* (o) smoothed output */
-       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,*psseq,err,errs;
-       float surround[BLOCKL_MAX]; /* shape contributed by other than
-                                      current */
-       float wt[2*ENH_HL+1];       /* waveform weighting to get
-                                      surround shape */
-       float denom;
-
-       /* 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)cos(2*PI*i/(2*hl+2)));
-       }
-       wt[hl]=0.0; /* for clarity, not used */
-       for (i=0; i<ENH_BLOCKL; i++) {
-           surround[i]=sseq[i]*wt[0];
-       }
-
-
-
-
-
-       for (k=1; k<hl; k++) {
-           psseq=sseq+k*ENH_BLOCKL;
-           for(i=0;i<ENH_BLOCKL; i++) {
-               surround[i]+=psseq[i]*wt[k];
-           }
-       }
-       for (k=hl+1; k<=2*hl; k++) {
-           psseq=sseq+k*ENH_BLOCKL;
-           for(i=0;i<ENH_BLOCKL; i++) {
-               surround[i]+=psseq[i]*wt[k];
-           }
-       }
-
-       /* compute some inner products */
-
-       w00 = w10 = w11 = 0.0;
-       psseq=sseq+hl*ENH_BLOCKL; /* current block  */
-       for (i=0; i<ENH_BLOCKL;i++) {
-           w00+=psseq[i]*psseq[i];
-           w11+=surround[i]*surround[i];
-           w10+=surround[i]*psseq[i];
-       }
-
-       if (fabs(w11) < 1.0) {
-           w11=1.0;
-       }
-       C = (float)sqrt( w00/w11);
-
-       /* first try enhancement without power-constraint */
-
-       errs=0.0;
-       psseq=sseq+hl*ENH_BLOCKL;
-       for (i=0; i<ENH_BLOCKL; i++) {
-           odata[i]=C*surround[i];
-           err=psseq[i]-odata[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.0001) { /* eliminates numerical problems
-                                    for if smooth */
-
-
-
-
-
-               A = (float)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.0;
-               B= 1.0;
-           }
-
-           /* create smoothed sequence */
-
-           psseq=sseq+hl*ENH_BLOCKL;
-           for (i=0; i<ENH_BLOCKL; i++) {
-               odata[i]=A*surround[i]+B*psseq[i];
-           }
-       }
-   }
-
-   /*----------------------------------------------------------------*
-    * get the pitch-synchronous sample sequence
-    *---------------------------------------------------------------*/
-
-   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[2*ENH_HL+1];
-       int lagBlock[2*ENH_HL+1];
-       float plocs2[ENH_PLOCSL];
-       float *psseq;
-
-       centerEndPos=centerStartPos+ENH_BLOCKL-1;
-
-       /* present */
-
-       NearestNeighbor(lagBlock+hl,plocs,
-           (float)0.5*(centerStartPos+centerEndPos),periodl);
-
-       blockStartPos[hl]=(float)centerStartPos;
-
-
-
-
-
-       psseq=sseq+ENH_BLOCKL*hl;
-       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]];
-           NearestNeighbor(lagBlock+q,plocs,
-               blockStartPos[q]+
-               ENH_BLOCKL_HALF-period[lagBlock[q+1]], periodl);
-
-
-           if (blockStartPos[q]-ENH_OVERHANG>=0) {
-               refiner(sseq+q*ENH_BLOCKL, blockStartPos+q, idata,
-                   idatal, centerStartPos, blockStartPos[q],
-                   period[lagBlock[q+1]]);
-           } else {
-               psseq=sseq+q*ENH_BLOCKL;
-               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++) {
-           NearestNeighbor(lagBlock+q,plocs2,
-               blockStartPos[q-1]+ENH_BLOCKL_HALF,periodl);
-
-           blockStartPos[q]=blockStartPos[q-1]+period[lagBlock[q]];
-           if (blockStartPos[q]+ENH_BLOCKL+ENH_OVERHANG<idatal) {
-               refiner(sseq+ENH_BLOCKL*q, blockStartPos+q, idata,
-                   idatal, centerStartPos, blockStartPos[q],
-                   period[lagBlock[q]]);
-           }
-           else {
-               psseq=sseq+q*ENH_BLOCKL;
-               memset(psseq, 0, ENH_BLOCKL*sizeof(float));
-           }
-       }
-   }
-
-   /*----------------------------------------------------------------*
-    * perform enhancement on idata+centerStartPos through
-    * idata+centerStartPos+ENH_BLOCKL-1
-    *---------------------------------------------------------------*/
-
-
-
-
-
-   void enhancer(
-       float *odata,       /* (o) smoothed block, dimension blockl */
-       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[(2*ENH_HL+1)*ENH_BLOCKL];
-
-       /* get said second sequence of segments */
-
-       getsseq(sseq,idata,idatal,centerStartPos,period,
-           plocs,periodl,ENH_HL);
-
-       /* compute the smoothed output from said second sequence */
-
-       smath(odata,sseq,ENH_HL,alpha0);
-
-   }
-
-   /*----------------------------------------------------------------*
-    * cross correlation
-    *---------------------------------------------------------------*/
-
-   float xCorrCoef(
-       float *target,      /* (i) first array */
-       float *regressor,   /* (i) second array */
-       int subl        /* (i) dimension arrays */
-   ){
-       int i;
-       float ftmp1, ftmp2;
-
-       ftmp1 = 0.0;
-       ftmp2 = 0.0;
-       for (i=0; i<subl; i++) {
-           ftmp1 += target[i]*regressor[i];
-           ftmp2 += regressor[i]*regressor[i];
-       }
-
-       if (ftmp1 > 0.0) {
-           return (float)(ftmp1*ftmp1/ftmp2);
-       }
-
-
-
-
-
-       else {
-           return (float)0.0;
-       }
-   }
-
-   /*----------------------------------------------------------------*
-    * interface for enhancer
-    *---------------------------------------------------------------*/
-
-   int enhancerInterface(
-       float *out,                     /* (o) enhanced signal */
-       float *in,                      /* (i) unenhanced signal */
-       iLBC_Dec_Inst_t *iLBCdec_inst   /* (i) buffers etc */
-   ){
-       float *enh_buf, *enh_period;
-       int iblock, isample;
-       int lag=0, ilag, i, ioffset;
-       float cc, maxcc;
-       float ftmp1, ftmp2;
-       float *inPtr, *enh_bufPtr1, *enh_bufPtr2;
-       float plc_pred[ENH_BLOCKL];
-
-       float lpState[6], downsampled[(ENH_NBLOCKS*ENH_BLOCKL+120)/2];
-       int inLen=ENH_NBLOCKS*ENH_BLOCKL+120;
-       int start, plc_blockl, inlag;
-
-       enh_buf=iLBCdec_inst->enh_buf;
-       enh_period=iLBCdec_inst->enh_period;
-
-       memmove(enh_buf, &enh_buf[iLBCdec_inst->blockl],
-           (ENH_BUFL-iLBCdec_inst->blockl)*sizeof(float));
-
-       memcpy(&enh_buf[ENH_BUFL-iLBCdec_inst->blockl], in,
-           iLBCdec_inst->blockl*sizeof(float));
-
-       if (iLBCdec_inst->mode==30)
-           plc_blockl=ENH_BLOCKL;
-       else
-           plc_blockl=40;
-
-       /* when 20 ms frame, move processing one block */
-       ioffset=0;
-       if (iLBCdec_inst->mode==20) ioffset=1;
-
-       i=3-ioffset;
-       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. */
-
-       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+(ENH_NBLOCKS_EXTRA+ioffset)*ENH_BLOCKL-120,
-                   lpFilt_coefsTbl, inLen-ioffset*ENH_BLOCKL,
-                   lpState, downsampled);
-
-       /* Estimate the pitch in the down sampled domain. */
-       for (iblock = 0; iblock<ENH_NBLOCKS-ioffset; iblock++) {
-
-           lag = 10;
-           maxcc = xCorrCoef(downsampled+60+iblock*
-               ENH_BLOCKL_HALF, downsampled+60+iblock*
-               ENH_BLOCKL_HALF-lag, ENH_BLOCKL_HALF);
-           for (ilag=11; ilag<60; ilag++) {
-               cc = xCorrCoef(downsampled+60+iblock*
-                   ENH_BLOCKL_HALF, downsampled+60+iblock*
-                   ENH_BLOCKL_HALF-ilag, ENH_BLOCKL_HALF);
-
-               if (cc > maxcc) {
-                   maxcc = cc;
-                   lag = ilag;
-               }
-           }
-
-           /* Store the estimated lag in the non-downsampled domain */
-           enh_period[iblock+ENH_NBLOCKS_EXTRA+ioffset] = (float)lag*2;
-
-
-       }
-
-
-       /* PLC was performed on the previous packet */
-       if (iLBCdec_inst->prev_enh_pl==1) {
-
-           inlag=(int)enh_period[ENH_NBLOCKS_EXTRA+ioffset];
-
-           lag = inlag-1;
-           maxcc = xCorrCoef(in, in+lag, plc_blockl);
-           for (ilag=inlag; ilag<=inlag+1; ilag++) {
-               cc = xCorrCoef(in, in+ilag, plc_blockl);
-
-
-
-
-
-
-               if (cc > maxcc) {
-                   maxcc = cc;
-                   lag = ilag;
-               }
-           }
-
-           enh_period[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];
-
-           enh_bufPtr1=&plc_pred[plc_blockl-1];
-
-           if (lag>plc_blockl) {
-               start=plc_blockl;
-           } else {
-               start=lag;
-           }
-
-           for (isample = start; isample>0; isample--) {
-               *enh_bufPtr1-- = *inPtr--;
-           }
-
-           enh_bufPtr2=&enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl];
-           for (isample = (plc_blockl-1-lag); isample>=0; isample--) {
-               *enh_bufPtr1-- = *enh_bufPtr2--;
-           }
-
-           /* limit energy change */
-           ftmp2=0.0;
-           ftmp1=0.0;
-           for (i=0;i<plc_blockl;i++) {
-               ftmp2+=enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl-i]*
-                   enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl-i];
-               ftmp1+=plc_pred[i]*plc_pred[i];
-           }
-           ftmp1=(float)sqrt(ftmp1/(float)plc_blockl);
-           ftmp2=(float)sqrt(ftmp2/(float)plc_blockl);
-           if (ftmp1>(float)2.0*ftmp2 && ftmp1>0.0) {
-               for (i=0;i<plc_blockl-10;i++) {
-                   plc_pred[i]*=(float)2.0*ftmp2/ftmp1;
-               }
-               for (i=plc_blockl-10;i<plc_blockl;i++) {
-                   plc_pred[i]*=(float)(i-plc_blockl+10)*
-                       ((float)1.0-(float)2.0*ftmp2/ftmp1)/(float)(10)+
-
-
-
-
-
-                       (float)2.0*ftmp2/ftmp1;
-               }
-           }
-
-           enh_bufPtr1=&enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl];
-           for (i=0; i<plc_blockl; i++) {
-               ftmp1 = (float) (i+1) / (float) (plc_blockl+1);
-               *enh_bufPtr1 *= ftmp1;
-               *enh_bufPtr1 += ((float)1.0-ftmp1)*
-                                   plc_pred[plc_blockl-1-i];
-               enh_bufPtr1--;
-           }
-       }
-
-       if (iLBCdec_inst->mode==20) {
-           /* Enhancer with 40 samples delay */
-           for (iblock = 0; iblock<2; iblock++) {
-               enhancer(out+iblock*ENH_BLOCKL, enh_buf,
-                   ENH_BUFL, (5+iblock)*ENH_BLOCKL+40,
-                   ENH_ALPHA0, enh_period, enh_plocsTbl,
-                       ENH_NBLOCKS_TOT);
-           }
-       } else if (iLBCdec_inst->mode==30) {
-           /* Enhancer with 80 samples delay */
-           for (iblock = 0; iblock<3; iblock++) {
-               enhancer(out+iblock*ENH_BLOCKL, enh_buf,
-                   ENH_BUFL, (4+iblock)*ENH_BLOCKL,
-                   ENH_ALPHA0, enh_period, enh_plocsTbl,
-                       ENH_NBLOCKS_TOT);
-           }
-       }
-
-       return (lag*2);
-   }
-
-- 
cgit v1.2.3