ilbc_encoder.java

FMJ（freedom media for java)是java视频开发的新选择

   }

    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 */