package cn.org.hentai.jtt1078.codec.g726;
|
|
public class G726State {
|
|
/** Locked or steady state step size multiplier. */
|
/*long*/int yl;
|
/** Unlocked or non-steady state step size multiplier. */
|
/*short*/int yu;
|
/** Short term energy estimate. */
|
/*short*/int dms;
|
/** Long term energy estimate. */
|
/*short*/int dml;
|
/** Linear weighting coefficient of 'yl' and 'yu'. */
|
/*short*/int ap;
|
|
/** Coefficients of pole portion of prediction filter. */
|
/*short*/int[] a;
|
/** Coefficients of zero portion of prediction filter. */
|
/*short*/int[] b;
|
/** Signs of previous two samples of a partially
|
* reconstructed signal. */
|
/*short*/int[] pk;
|
/** Previous 6 samples of the quantized difference
|
* signal represented in an internal floating point
|
* format. */
|
/*short*/int[] dq;
|
/** Previous 2 samples of the quantized difference
|
* signal represented in an internal floating point
|
* format. */
|
/*short*/int[] sr;
|
/* delayed tone detect, new in 1988 version */
|
/*char*/int td;
|
|
|
/** The first 15 values, powers of 2. */
|
private static final /*short*/int[] power2 = { 1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000 };
|
|
|
/** Quantizes the input val against the table of size short integers.
|
* It returns i if table[i-1]<=val<table[i].
|
* <p>
|
* Using linear search for simple coding. */
|
private static int quan(int val, /*short*/int[] table, int size) {
|
|
int i;
|
for (i=0; i<size; i++) if (val<table[i]) break;
|
return i;
|
}
|
|
|
/** returns the integer product of the 14-bit integer "an" and
|
* "floating point" representation (4-bit exponent, 6-bit mantessa) "srn". */
|
private static int fmult(int an, int srn) {
|
|
/*short*/int anmag=(an>0)? an : ((-an)&0x1FFF);
|
/*short*/int anexp=quan(anmag, power2, 15)-6;
|
/*short*/int anmant=(anmag==0)? 32 :
|
(anexp >= 0)? anmag>>anexp : anmag<<-anexp;
|
/*short*/int wanexp=anexp + ((srn>>6)&0xF) - 13;
|
|
/*short*/int wanmant=(anmant*(srn&077) + 0x30)>>4;
|
/*short*/int retval=(wanexp>=0)? ((wanmant<<wanexp)&0x7FFF) : (wanmant>>-wanexp);
|
|
return (((an^srn)<0)? -retval : retval);
|
}
|
|
|
/** Creates a new G726State. */
|
public G726State() {
|
a=new /*short*/int[2];
|
b=new /*short*/int[6];
|
pk=new /*short*/int[2];
|
dq=new /*short*/int[6];
|
sr=new /*short*/int[2];
|
init();
|
}
|
|
/** This routine initializes and/or resets the G726State 'state'. <br>
|
* All the initial state values are specified in the CCITT G.721 document. */
|
private void init() {
|
yl=34816;
|
yu=544;
|
dms=0;
|
dml=0;
|
ap=0;
|
for (int cnta=0; cnta<2; cnta++) {
|
a[cnta]=0;
|
pk[cnta]=0;
|
sr[cnta]=32;
|
}
|
for (int cnta=0; cnta<6; cnta++) {
|
b[cnta]=0;
|
dq[cnta]=32;
|
}
|
td=0;
|
}
|
|
/** computes the estimated signal from 6-zero predictor. */
|
public int predictor_zero() {
|
|
int sezi=fmult(b[0]>>2, dq[0]);
|
/* ACCUM */
|
for (int i=1; i<6; i++) sezi+=fmult(b[i]>>2,dq[i]);
|
return sezi;
|
}
|
|
|
/** computes the estimated signal from 2-pole predictor. */
|
public int predictor_pole() {
|
|
return (fmult(a[1]>>2,sr[1]) + fmult(a[0]>>2,sr[0]));
|
}
|
|
|
/** computes the quantization step size of the adaptive quantizer. */
|
public int step_size() {
|
|
if (ap>=256) return (yu);
|
else {
|
int y=yl>>6;
|
int dif=yu-y;
|
int al=ap>>2;
|
if (dif>0) y+=(dif * al)>>6;
|
else
|
if (dif<0) y+=(dif * al+0x3F)>>6;
|
return y;
|
}
|
}
|
}
|
