|
package cn.org.hentai.jtt1078.codec.g726;
|
|
|
import cn.org.hentai.jtt1078.codec.G711Codec;
|
import cn.org.hentai.jtt1078.codec.G711UCodec;
|
|
/** Common routines for G.721 and G.723 conversions.
|
* <p>
|
* This implementation is based on the ANSI-C language reference implementations
|
* of the CCITT (International Telegraph and Telephone Consultative Committee)
|
* G.711, G.721 and G.723 voice compressions, provided by Sun Microsystems, Inc.
|
* <p>
|
* Acknowledgement to Sun Microsystems, Inc. for having released the original
|
* ANSI-C source code to the public domain.
|
*/
|
public abstract class G726 {
|
|
// ##### C-to-Java conversion: #####
|
// short becomes int
|
// char becomes int
|
// unsigned char becomes int
|
|
|
// *************************** STATIC ***************************
|
|
/** ISDN u-law */
|
public static final int AUDIO_ENCODING_ULAW=1;
|
|
/** ISDN A-law */
|
public static final int AUDIO_ENCODING_ALAW=2;
|
|
/** PCM 2's-complement (0-center) */
|
public static final int AUDIO_ENCODING_LINEAR=3;
|
|
|
|
/** 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;
|
}
|
|
|
/** Given a raw sample, 'd', of the difference signal and a
|
* quantization step size scale factor, 'y', this routine returns the
|
* ADPCM codeword to which that sample gets quantized. The step
|
* size scale factor division operation is done in the log base 2 domain
|
* as a subtraction.
|
* <br>
|
* @param d - Raw difference signal sample
|
* @param y - Step size multiplier
|
* @param table - Quantization table
|
* @param size - Table size of short integers
|
*/
|
protected static int quantize(int d, int y, /*short*/int[] table, int size) {
|
|
/* LOG
|
* Compute base 2 log of 'd', and store in 'dl'.
|
*/
|
/*short*/int dqm=Math.abs(d); /* Magnitude of 'd' */
|
|
/*short*/int exp=quan(dqm>>1, power2, 15); /* Integer part of base 2 log of 'd' */
|
|
/*short*/int mant=((dqm<<7)>>exp)&0x7F; /* Fractional part of base 2 log */
|
|
/*short*/int dl=(exp<<7)+mant; /* Log of magnitude of 'd' */
|
|
/* SUBTB
|
* "Divide" by step size multiplier.
|
*/
|
/* Step size scale factor normalized log */
|
/*short*/int dln=dl-(y>>2);
|
|
/* QUAN
|
* Obtain codword i for 'd'.
|
*/
|
int i=quan(dln, table, size);
|
if (d<0) /* take 1's complement of i */
|
return ((size<<1)+1-i);
|
else if (i==0) /* take 1's complement of 0 */
|
return ((size<<1)+1); /* new in 1988 */
|
else
|
return (i);
|
}
|
|
|
/** Returns reconstructed difference signal 'dq' obtained from
|
* codeword 'i' and quantization step size scale factor 'y'.
|
* Multiplication is performed in log base 2 domain as addition.
|
* @param sign - 0 for non-negative value
|
* @param dqln - G.72x codeword
|
* @param y - Step size multiplier
|
*/
|
protected static int reconstruct(int sign, int dqln, int y) {
|
|
/* Log of 'dq' magnitude */
|
/*short*/int dql=dqln+(y>>2); /* ADDA */
|
|
if (dql<0) {
|
return ((sign!=0)? -0x8000 : 0);
|
}
|
else {
|
/* ANTILOG */
|
/* Integer part of log */
|
/*short*/int dex=(dql>>7)&15;
|
/*short*/int dqt=128+(dql&127);
|
/* Reconstructed difference signal sample */
|
/*short*/int dq=(dqt<<7)>>(14-dex);
|
return ((sign!=0)? (dq-0x8000) : dq);
|
}
|
}
|
|
|
/** updates the state variables for each output code
|
* @param code_size - distinguish 723_40 with others
|
* @param y - quantizer step size
|
* @param wi - scale factor multiplier
|
* @param fi - for long/short term energies
|
* @param dq - quantized prediction difference
|
* @param sr - reconstructed signal
|
* @param dqsez - difference from 2-pole predictor
|
* @param state - coder state
|
*/
|
protected static void update(int code_size, int y, int wi, int fi, int dq, int sr, int dqsez, G726State state) {
|
|
int cnt;
|
/*short*/int mag, exp, mant; /* Adaptive predictor, FLOAT A */
|
/*short*/int a2p; /* LIMC */
|
/*short*/int a1ul; /* UPA1 */
|
/*short*/int ua2, pks1; /* UPA2 */
|
/*short*/int uga2a, fa1;
|
/*short*/int uga2b;
|
/*char*/int tr; /* tone/transition detector */
|
/*short*/int ylint, thr2, dqthr;
|
/*short*/int ylfrac, thr1;
|
/*short*/int pk0;
|
|
// ##### C-to-Java conversion: #####
|
// init a2p
|
a2p=0;
|
|
pk0=(dqsez<0)? 1 : 0; /* needed in updating predictor poles */
|
|
mag=dq&0x7FFF; /* prediction difference magnitude */
|
/* TRANS */
|
ylint=state.yl>>15; /* exponent part of yl */
|
ylfrac=(state.yl>>10)&0x1F; /* fractional part of yl */
|
thr1=(32+ylfrac)<<ylint; /* threshold */
|
thr2=(ylint>9)? 31<<10 : thr1; /* limit thr2 to 31<<10 */
|
dqthr=(thr2+(thr2>>1))>>1; /* dqthr=0.75 * thr2 */
|
if (state.td==0) /* signal supposed voice */
|
tr=0;
|
else
|
if (mag<=dqthr) /* supposed data, but small mag */
|
tr=0; /* treated as voice */
|
else /* signal is data (modem) */
|
tr=1;
|
|
/* Quantizer scale factor adaptation. */
|
|
/* FUNCTW&FILTD&DELAY */
|
/* update non-steady state step size multiplier */
|
state.yu=y+((wi-y)>>5);
|
|
/* LIMB */
|
if (state.yu<544) /* 544<=yu<=5120 */
|
state.yu=544;
|
else
|
if (state.yu>5120)
|
state.yu=5120;
|
|
/* FILTE&DELAY */
|
/* update steady state step size multiplier */
|
state.yl+=state.yu+((-state.yl)>>6);
|
|
/*
|
* Adaptive predictor coefficients.
|
*/
|
if (tr==1) {
|
/* reset a's and b's for modem signal */
|
state.a[0]=0;
|
state.a[1]=0;
|
state.b[0]=0;
|
state.b[1]=0;
|
state.b[2]=0;
|
state.b[3]=0;
|
state.b[4]=0;
|
state.b[5]=0;
|
}
|
else {
|
/* update a's and b's */
|
pks1=pk0^state.pk[0]; /* UPA2 */
|
|
/* update predictor pole a[1] */
|
a2p=state.a[1]-(state.a[1]>>7);
|
if (dqsez != 0) {
|
fa1=(pks1!=0)? state.a[0] : -state.a[0];
|
if (fa1<-8191) /* a2p=function of fa1 */
|
a2p-=0x100;
|
else
|
if (fa1>8191)
|
a2p+=0xFF;
|
else
|
a2p+=fa1>>5;
|
|
if ((pk0^state.pk[1])!=0) {
|
/* LIMC */
|
if (a2p<=-12160)
|
a2p=-12288;
|
else
|
if (a2p>=12416)
|
a2p=12288;
|
else
|
a2p-=0x80;
|
}
|
else
|
if (a2p<=-12416)
|
a2p=-12288;
|
else
|
if (a2p>=12160)
|
a2p=12288;
|
else
|
a2p+=0x80;
|
}
|
|
/* TRIGB&DELAY */
|
state.a[1]=a2p;
|
|
/* UPA1 */
|
/* update predictor pole a[0] */
|
state.a[0] -= state.a[0]>>8;
|
if (dqsez != 0)
|
if (pks1==0)
|
state.a[0]+=192;
|
else
|
state.a[0] -= 192;
|
|
/* LIMD */
|
a1ul=15360-a2p;
|
if (state.a[0]<-a1ul)
|
state.a[0]=-a1ul;
|
else if (state.a[0]>a1ul)
|
state.a[0]=a1ul;
|
|
/* UPB : update predictor zeros b[6] */
|
for (cnt=0; cnt<6; cnt++) {
|
|
if (code_size==5) /* for 40Kbps G.723 */
|
state.b[cnt]-=state.b[cnt]>>9;
|
else /* for G.721 and 24Kbps G.723 */
|
state.b[cnt]-=state.b[cnt]>>8;
|
if ((dq&0x7FFF)!=0) {
|
/* XOR */
|
if ((dq^state.dq[cnt])>=0)
|
state.b[cnt]+=128;
|
else
|
state.b[cnt]-=128;
|
}
|
}
|
}
|
|
for (cnt=5; cnt>0; cnt--) state.dq[cnt]=state.dq[cnt-1];
|
/* FLOAT A : convert dq[0] to 4-bit exp, 6-bit mantissa f.p. */
|
if (mag==0) {
|
state.dq[0]=(dq>=0)? 0x20 : 0xFC20;
|
}
|
else {
|
exp=quan(mag, power2, 15);
|
state.dq[0]=(dq>=0) ? (exp<<6)+((mag<<6)>>exp) : (exp<<6)+((mag<<6)>>exp)-0x400;
|
}
|
|
state.sr[1]=state.sr[0];
|
/* FLOAT B : convert sr to 4-bit exp., 6-bit mantissa f.p. */
|
if (sr==0) {
|
state.sr[0]=0x20;
|
}
|
else
|
if (sr>0) {
|
exp=quan(sr, power2, 15);
|
state.sr[0]=(exp<<6)+((sr<<6)>>exp);
|
}
|
else
|
if (sr>-32768) {
|
mag=-sr;
|
exp=quan(mag, power2, 15);
|
state.sr[0]=(exp<<6)+((mag<<6)>>exp)-0x400;
|
}
|
else
|
state.sr[0]=0xFC20;
|
|
/* DELAY A */
|
state.pk[1]=state.pk[0];
|
state.pk[0]=pk0;
|
|
/* TONE */
|
if (tr==1) /* this sample has been treated as data */
|
state.td=0; /* next one will be treated as voice */
|
else
|
if (a2p<-11776) /* small sample-to-sample correlation */
|
state.td=1; /* signal may be data */
|
else /* signal is voice */
|
state.td=0;
|
|
/*
|
* Adaptation speed control.
|
*/
|
state.dms+=(fi-state.dms)>>5; /* FILTA */
|
state.dml+=(((fi<<2)-state.dml)>>7); /* FILTB */
|
|
if (tr==1)
|
state.ap=256;
|
else
|
if (y<1536) /* SUBTC */
|
state.ap+=(0x200-state.ap)>>4;
|
else
|
if (state.td==1)
|
state.ap+=(0x200-state.ap)>>4;
|
else
|
if (Math.abs((state.dms<<2)-state.dml)>=(state.dml>>3))
|
state.ap+=(0x200-state.ap)>>4;
|
else
|
state.ap+=(-state.ap)>>4;
|
}
|
|
/** At the end of ADPCM decoding, it simulates an encoder which may be receiving
|
* the output of this decoder as a tandem process. If the output of the
|
* simulated encoder differs from the input to this decoder, the decoder output
|
* is adjusted by one level of A-law or u-law codes.
|
*
|
* @param sr - decoder output linear PCM sample,
|
* @param se - predictor estimate sample,
|
* @param y - quantizer step size,
|
* @param i - decoder input code,
|
* @param sign - sign bit of code i
|
*
|
* @return adjusted A-law or u-law compressed sample.
|
*/
|
protected static int tandem_adjust_alaw(int sr, int se, int y, int i, int sign, /*short*/int[] qtab) {
|
|
/*unsigned char*/int sp; /* A-law compressed 8-bit code */
|
/*short*/int dx; /* prediction error */
|
/*char*/int id; /* quantized prediction error */
|
int sd; /* adjusted A-law decoded sample value */
|
int im; /* biased magnitude of i */
|
int imx; /* biased magnitude of id */
|
|
if (sr<=-32768) sr=-1;
|
sp= G711Codec.linear2alaw((short)((sr>>1)<<3)); /* short to A-law compression */
|
dx=(G711Codec.alaw2linear((byte)sp)>>2)-se; /* 16-bit prediction error */
|
id=quantize(dx, y, qtab, sign-1);
|
|
if (id==i) {
|
/* no adjustment on sp */
|
return (sp);
|
}
|
else {
|
/* sp adjustment needed */
|
/* ADPCM codes : 8, 9, ... F, 0, 1, ... , 6, 7 */
|
im=i^sign; /* 2's complement to biased unsigned */
|
imx=id^sign;
|
|
if (imx>im) {
|
/* sp adjusted to next lower value */
|
if ((sp&0x80)!=0) {
|
sd=(sp==0xD5)? 0x55 : ((sp^0x55)-1)^0x55;
|
}
|
else {
|
sd=(sp==0x2A)? 0x2A : ((sp^0x55)+1)^0x55;
|
}
|
}
|
else {
|
/* sp adjusted to next higher value */
|
if ((sp&0x80)!=0)
|
sd=(sp==0xAA)? 0xAA : ((sp^0x55)+1)^0x55;
|
else
|
sd=(sp==0x55)? 0xD5 : ((sp^0x55)-1)^0x55;
|
}
|
return (sd);
|
}
|
}
|
|
/** @param sr - decoder output linear PCM sample
|
* @param se - predictor estimate sample
|
* @param y - quantizer step size
|
* @param i - decoder input code
|
* @param sign
|
* @param qtab
|
*/
|
protected static int tandem_adjust_ulaw(int sr, int se, int y, int i, int sign, /*short*/int[] qtab) {
|
|
/*unsigned char*/int sp; /* u-law compressed 8-bit code */
|
/*short*/int dx; /* prediction error */
|
/*char*/int id; /* quantized prediction error */
|
int sd; /* adjusted u-law decoded sample value */
|
int im; /* biased magnitude of i */
|
int imx; /* biased magnitude of id */
|
|
if (sr<=-32768) sr=0;
|
sp= G711UCodec.linear2ulaw((short)(sr<<2)); /* short to u-law compression */
|
dx=(G711UCodec.ulaw2linear((byte)sp)>>2)-se; /* 16-bit prediction error */
|
id=quantize(dx, y, qtab, sign-1);
|
if (id==i) {
|
return (sp);
|
}
|
else {
|
/* ADPCM codes : 8, 9, ... F, 0, 1, ... , 6, 7 */
|
im=i^sign; /* 2's complement to biased unsigned */
|
imx=id^sign;
|
if (imx>im) {
|
/* sp adjusted to next lower value */
|
if ((sp&0x80)!=0)
|
sd=(sp==0xFF)? 0x7E : sp+1;
|
else
|
sd=(sp==0)? 0 : sp-1;
|
|
}
|
else {
|
/* sp adjusted to next higher value */
|
if ((sp&0x80)!=0)
|
sd=(sp==0x80)? 0x80 : sp-1;
|
else
|
sd=(sp==0x7F)? 0xFE : sp+1;
|
}
|
return (sd);
|
}
|
}
|
|
|
// ##### C-to-Java conversion: #####
|
|
/** Converts a byte into an unsigned int. */
|
protected static int unsignedInt(byte b) {
|
return ((int)b+0x100)&0xFF;
|
}
|
|
// ##### 2 bytes to int conversion: #####
|
|
/** Converts 2 little-endian-bytes into an unsigned int. */
|
public static int unsignedIntLittleEndian(byte hi_b, byte lo_b) {
|
return (unsignedInt(hi_b)<<8) + unsignedInt(lo_b);
|
}
|
|
/** Converts 2 little-endian-bytes into a signed int. */
|
public static int signedIntLittleEndian(byte hi_b, byte lo_b) {
|
int sign_bit=hi_b>>7;
|
return (sign_bit==0)? (unsignedInt(hi_b)<<8) + unsignedInt(lo_b) : (-1^0x7FFF)^(((unsignedInt(hi_b)&0x7F)<<8) + unsignedInt(lo_b));
|
}
|
|
|
// ************************* NON-STATIC *************************
|
|
/** Encoding state */
|
G726State state;
|
|
int type;
|
|
/** Creates a new G726 processor, that can be used to encode from or decode do PCM audio data. */
|
public G726(int type) {
|
this.type = type;
|
state=new G726State();
|
}
|
|
public int getType() {
|
return type;
|
}
|
|
/** Encodes the input vale of linear PCM, A-law or u-law data sl and returns
|
* the resulting code. -1 is returned for unknown input coding value. */
|
public abstract int encode(int sl, int in_coding);
|
|
|
/** Encodes the input chunk in_buff of linear PCM, A-law or u-law data and returns
|
* the G726 encoded chuck into out_buff. <br>
|
* It returns the actual size of the output data, or -1 in case of unknown
|
* in_coding value. */
|
public abstract int encode(byte[] in_buff, int in_offset, int in_len, int in_coding, byte[] out_buff, int out_offset);
|
|
|
/** Decodes a 4-bit code of G.72x encoded data of i and
|
* returns the resulting linear PCM, A-law or u-law value.
|
* return -1 for unknown out_coding value. */
|
public abstract int decode(int i, int out_coding);
|
|
|
/** Decodes the input chunk in_buff of G726 encoded data and returns
|
* the linear PCM, A-law or u-law chunk into out_buff. <br>
|
* It returns the actual size of the output data, or -1 in case of unknown
|
* out_coding value. */
|
public abstract int decode(byte[] in_buff, int in_offset, int in_len, int out_coding, byte[] out_buff, int out_offset);
|
|
}
|
