G726_delaya(&r, &state->pk0, &state->pk1);    G726_addc(&dq, &sez, &state->pk0, &sigpk);    /* 4.2.6: find sr0 */    G726_addb(&dq, &se, &sr);    G726_floatb(&sr, &state->sr0);    /* 4.2.6: find dq0 */    G726_floata(&dq, &state->dq0);    /* Process 4.2.8 */    G726_compress(&sr, law, &sp);    G726_expand(&sp, law, &slx);    G726_subta(&slx, &se, &dx);    G726_log(&dx, &dlx, &dsx);    G726_subtb(&dlx, &y, &dlnx);    G726_sync(rate, &i, &sp, &dlnx, &dsx, law, &sd);    /* Save output PCM word in output buffer */    out_buf[j] = sd;    /* 4.2.6: prepar a2(r) */    G726_upa2(&state->pk0, &state->pk1, &pk2, &a2, &a1, &sigpk, &a2t);    G726_limc(&a2t, &a2p);    G726_trigb(&tr, &a2p, &state->a2r);    /* 4.2.6: prepar a1(r) */    G726_upa1(&state->pk0, &state->pk1, &a1, &sigpk, &a1t);    G726_limd(&a1t, &a2p, &a1p);    G726_trigb(&tr, &a1p, &state->a1r);    /* Remaining of 4.2.7 */    G726_tone(&a2p, &tdp);    G726_trigb(&tr, &tdp, &state->tdr);    /* Remaining of 4.2.5 */    G726_subtc(&state->dmsp, &state->dmlp, &tdp, &y, &ax);    G726_filtc(&ax, &ap, &app);    G726_triga(&tr, &app, &state->apr);    /* Remaining of 4.2.6: update of all `b's */    G726_xor(&state->dq1, &dq, &u1);	/* Here, b1 */    G726_upb(rate, &u1, &b1, &dq, &b1p);    G726_trigb(&tr, &b1p, &state->b1r);    G726_xor(&state->dq2, &dq, &u2);	/* Here, b2 */    G726_upb(rate, &u2, &b2, &dq, &b2p);    G726_trigb(&tr, &b2p, &state->b2r);    G726_xor(&state->dq3, &dq, &u3);	/* Here, b3 */    G726_upb(rate, &u3, &b3, &dq, &b3p);    G726_trigb(&tr, &b3p, &state->b3r);    G726_xor(&state->dq4, &dq, &u4);	/* Here, b4 */    G726_upb(rate, &u4, &b4, &dq, &b4p);    G726_trigb(&tr, &b4p, &state->b4r);    G726_xor(&state->dq5, &dq, &u5);	/* Here, b5 */    G726_upb(rate, &u5, &b5, &dq, &b5p);    G726_trigb(&tr, &b5p, &state->b5r);    G726_xor(&dq6, &dq, &u6);	/* At last, b6 */    G726_upb(rate, &u6, &b6, &dq, &b6p);    G726_trigb(&tr, &b6p, &state->b6r);  }  /* Invert even bits if A law */  if (*law == '1')  {    for (j = 0; j < smpno; j++)      out_buf[j] ^= 85;  }}/* ...................... end of G726_decode() ...................... *//*  ----------------------------------------------------------------------        void G726_expand (short *s, char *law, short *sl);        ~~~~~~~~~~~~~~~~        Description:        ~~~~~~~~~~~~        Convert either a-law (law=1) or u-law (law=0)  to uniform pcm. 	Inputs: s (sp in decoder), law 	Output: sl (slx in decoder)        Return value:  none.        ~~~~~~~~~~~~~        Prototype:   in g726.h        ~~~~~~~~~~        History:        ~~~~~~~~        31.Jan.91 v1.0f Release of 1st Fortran version to UGST.        		<tdsindi@venus.cpqd.ansp.br>        13.Feb.92 v1.0c 1st version in C translated from Fortran (f2c)        		<tdsimao@venus.cpqd.ansp.br> ----------------------------------------------------------------------*/void            G726_expand(s, law, sl)  short          *s;  char           *law;  short          *sl;{  long            mant, iexp;  short           s1, ss, sig, ssm, ssq, sss;  s1 = *s;  if (*law == '1')  {    /* Invert sign bit */    s1 ^= 128;    if (s1 >= 128)    {      s1 += -128;      sig = 4096;    }    else    {      sig = 0;    }    iexp = s1 / 16;    mant = s1 - (iexp << 4);    ss = (iexp == 0) ?      ((mant << 1) + 1 + sig) :      ((1 << (iexp - 1)) * ((mant << 1) + 33) + sig);    sss = ss / 4096;    ssm = ss & 4095;    ssq = ssm << 1;  }  else  {    /* Invert sign bit */    s1 ^= 128;    if (s1 >= 128)    {      s1 += -128;      s1 ^= 127;      sig = 8192;    }    else    {      sig = 0;      s1 ^= 127;    }    iexp = s1 / 16;    mant = s1 - (iexp << 4);    ss = (iexp == 0) ?      ((mant << 1) + sig) :      ((1 << iexp) * ((mant << 1) + 33) - 33 + sig);    sss = ss / 8192;    ssq = ss & 8191;  }  *sl = (sss == 0) ? ssq : ((16384 - ssq) & 16383);}/* ...................... end of G726_expand() ...................... *//* ----------------------------------------------------------------------        void G726_subta (short *sl, short *se, short *d);        ~~~~~~~~~~~~~~~        Description:        ~~~~~~~~~~~~        Compute difference signal by subtracting  signal estimate from        input signal (or  quantized reconstructed signal in decoder). 	Inputs: sl (slx in decoder), se 	Output: d  (dx in decoder)        Return value:  none.        ~~~~~~~~~~~~~        Prototype:   in g726.h        ~~~~~~~~~~        History:        ~~~~~~~~        31.Jan.91 v1.0f Release of 1st Fortran version to UGST.        		<tdsindi@venus.cpqd.ansp.br>        13.Feb.92 v1.0c 1st version in C translated from Fortran (f2c)        		<tdsimao@venus.cpqd.ansp.br> ----------------------------------------------------------------------*/void            G726_subta(sl, se, d)  short          *sl, *se, *d;{  long            se1;  long            sl1, sei, sli;  short           ses, sls;  sls = (*sl >> 13);  sl1 = *sl;  se1 = *se;  /* Sign extension */  sli = (sls == 0) ? sl1 : (sl1 + 49152);  ses = (*se >> 14);  /* Sign extension */  sei = (ses == 0) ? se1 : (se1 + 32768);  /* 16 bit TC */  *d = (short) ((sli + 65536 - sei) & 65535);}/* ......................... end of G726_subta() ......................... *//*  --------------------------------------------------------------------------        void G726_log (short *d, short *dl, short *ds);        ~~~~~~~~~~~~~        Description:        ~~~~~~~~~~~~        Convert difference signal from linear to the logarithmic domain.        Prototype: in g726.h        ~~~~~~~~~~        History:        ~~~~~~~~        31.Jan.91 v1.0f 1st release to UGST, in Fortran.                        <tdsindi@venus.cpqd.ansp.br>        13.Feb.92 v1.0c release of 1st version, in C. 	                <tdsimao@venus.cpqd.ansp.br>  --------------------------------------------------------------------------*/void            G726_log(d, dl, ds)  short          *d, *dl, *ds;{  long            mant;  long            d1;  long            dqm, exp_;  *ds = (*d >> 15);  d1 = *d;  /* Convert from 2-complement to signed magnitude */  dqm = (*ds) ? ((65536 - d1) & 32767) : d1;  /* Compute exponent */  if (dqm >= 16384)    exp_ = 14;  else if (dqm >= 8192)    exp_ = 13;  else if (dqm >= 4096)    exp_ = 12;  else if (dqm >= 2048)    exp_ = 11;  else if (dqm >= 1024)    exp_ = 10;  else if (dqm >= 512)    exp_ = 9;  else if (dqm >= 256)    exp_ = 8;  else if (dqm >= 128)    exp_ = 7;  else if (dqm >= 64)    exp_ = 6;  else if (dqm >= 32)    exp_ = 5;  else if (dqm >= 16)    exp_ = 4;  else if (dqm >= 8)    exp_ = 3;  else if (dqm >= 4)    exp_ = 2;  else if (dqm >= 2)    exp_ = 1;  else    exp_ = 0;  /* Compute approximation log2(1+x) = x */  mant = ((dqm << 7) >> exp_) & 127;  /* Combine mantissa and exponent (7 and 4) bits into a 11-bit word */  *dl = (short) ((exp_ << 7) + mant);}/* ........................ end of G726_log() ....................... *//* ----------------------------------------------------------------------        void G726_quan (short rate, short *dln, short *ds, short *i);        ~~~~~~~~~~~~~~        Description:        ~~~~~~~~~~~~        Quantize difference signal in logarithmic 	domain. 	Inputs: dln, ds, rate 	Output: i        Return value:  none.        ~~~~~~~~~~~~~        Prototype:   in g726.h        ~~~~~~~~~~        History:        ~~~~~~~~        31.Jan.91 v1.0f Release of 1st Fortran version to UGST.        		<tdsindi@venus.cpqd.ansp.br>        13.Feb.92 v1.0c 1st version in C translated from Fortran (f2c)        		<tdsimao@venus.cpqd.ansp.br> ----------------------------------------------------------------------*/void            G726_quan(rate, dln, ds, i)  short          *dln, *ds, *i;  short           rate;{  if (rate == 4)  {    if (*dln >= 3972)      *i = 1;    else if (*dln >= 2048)      *i = 15;    else if (*dln >= 400)      *i = 7;    else if (*dln >= 349)      *i = 6;    else if (*dln >= 300)      *i = 5;    else if (*dln >= 246)      *i = 4;    else if (*dln >= 178)      *i = 3;    else if (*dln >= 80)      *i = 2;    else      *i = 1;    /* Adjust for sign */    if (*ds)      *i = 15 - *i;    if (*i == 0)      *i = 15;  }				/* ......... end of 32 kbit part ........... */  else if (rate == 3)  {    if (*dln >= 2048)      *i = 7;    else if (*dln >= 331)      *i = 3;    else if (*dln >= 218)      *i = 2;    else if (*dln >= 8)      *i = 1;    else if (*dln >= 0)      *i = 7;    /* Adjust for sign */    if (*ds)      *i = 7 - *i;    if (*i == 0)      *i = 7;  }				/* ......... end of 24 kbit part ........... */  else if (rate == 2)  {    if (*dln >= 2048)      *i = 0;    else if (*dln >= 261)      *i = 1;    else      *i = 0;    /* Adjust for sign */    if (*ds)      *i = 3 - *i;  }				/* ......... end of 16 kbit part ........... */  else  {    if (*dln >= 4080)      *i = 2;    else if (*dln >= 3974)      *i = 1;    else if (*dln >= 2048)      *i = 31;    else if (*dln >= 553)      *i = 15;    else if (*dln >= 528)      *i = 14;    else if (*dln >= 502)      *i = 13;    else if (*dln >= 475)      *i = 12;    else if (*dln >= 445)      *i = 11;    else if (*dln >= 413)      *i = 10;    else if (*dln >= 378)      *i = 9;    else if (*dln >= 339)      *i = 8;    else if (*dln >= 298)      *i = 7;    else if (*dln >= 250)      *i = 6;    else if (*dln >= 198)      *i = 5;    else if (*dln >= 139)      *i = 4;    else if (*dln >= 68)      *i = 3;    else if (*dln >= 0)      *i = 2;    if (*ds)      *i = 31 - *i;    if (*i == 0)      *i = 31;  }				/* ......... end of 40 kbit part ........... */}/* ........................ end of G726_quan() ........................ *//* ----------------------------------------------------------------------        void G726_subtb (short *dl, short *y, short *dln);        ~~~~~~~~~~~~~~~        Description:        ~~~~~~~~~~~~        Scale logarithmic version of difference signal  by subtracting        scale factor. 	Inputs:   dl (dlx no decodificador), y 	Output:   dln (dlnx no decodificador)        Return value:  none.        ~~~~~~~~~~~~~        Prototype:   in g726.h        ~~~~~~~~~~        History:        ~~~~~~~~        31.Jan.91 v1.0f Release of 1st Fortran version to UGST.        		<tdsindi@venus.cpqd.ansp.br>        13.Feb.92 v1.0c 1st version in C translated from Fortran (f2c)        		<tdsimao@venus.cpqd.ansp.br> ----------------------------------------------------------------------*/void            G726_subtb(dl, y, dln)  short          *dl, *y, *dln;{  *dln = (*dl + 4096 - (*y >> 2)) & 4095;}/* ........................ end of G726_subtb() ........................ *//* ----------------------------------------------------------------------        void G726_adda (short *dqln, short *y, short *dql);        ~~~~~~~~~~~~~~        Description:        ~~~~~~~~~~~~        Addition of scale factor to logarithmic  version of quantized        difference signal. 	Inputs: dqln, y 	Output: dql        Return value:  none.        ~~~~~~~~~~~~~        Prototype:   in g726.h        ~~~~~~~~~~