ilbc_decoder.java

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

	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;
    }
}