g723.cpp

GNU ccAudio2 is a stand-alone portable C++ class framework for manipulating audio data. It has exist

/*
 * update()
 *
 * updates the state variables for each output code
 */
void g72x::update(int code_size, int y, int wi, int fi, int dq, int sr, int dqsez)
{
        int             cnt;
        short           mag, exp;       /* Adaptive predictor, FLOAT A */
        short           a2p=0;          /* LIMC */
        short           a1ul;           /* UPA1 */
        short           pks1;           /* UPA2 */
        short           fa1;
        char            tr;             /* tone/transition detector */
        short           ylint, thr2, dqthr;
        short           ylfrac, thr1;
        short           pk0;

        pk0 = (dqsez < 0) ? 1 : 0;      /* needed in updating predictor poles */

        mag = dq & 0x7FFF;              /* prediction difference magnitude */
        /* TRANS */
        ylint = g72x::yl >> 15;    /* exponent part of yl */
        ylfrac = (g72x::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 (g72x::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 */
        g72x::yu = y + ((wi - y) >> 5);

        /* LIMB */
        if (g72x::yu < 544)        /* 544 <= yu <= 5120 */
                g72x::yu = 544;
        else if (g72x::yu > 5120)
                g72x::yu = 5120;

        /* FILTE & DELAY */
        /* update steady state step size multiplier */
        g72x::yl += g72x::yu + ((-g72x::yl) >> 6);

        /*
         * Adaptive predictor coefficients.
         */
        if (tr == 1) {                  /* reset a's and b's for modem signal */
                g72x::a[0] = 0;
                g72x::a[1] = 0;
                g72x::b[0] = 0;
                g72x::b[1] = 0;
                g72x::b[2] = 0;
                g72x::b[3] = 0;
                g72x::b[4] = 0;
                g72x::b[5] = 0;
        } else {                        /* update a's and b's */
                pks1 = pk0 ^ g72x::pk[0];          /* UPA2 */

                /* update predictor pole a[1] */
                a2p = g72x::a[1] - (g72x::a[1] >> 7);
                if (dqsez != 0) {
                        fa1 = (pks1) ? g72x::a[0] : -g72x::a[0];
                        if (fa1 < -8191)        /* a2p = function of fa1 */
                                a2p -= 0x100;
                        else if (fa1 > 8191)
                                a2p += 0xFF;
                        else
                                a2p += fa1 >> 5;

                        if (pk0 ^ g72x::pk[1])
                        {
                                /* 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;
                }

                /* Possible bug: a2p not initialized if dqsez == 0) */
                /* TRIGB & DELAY */
                g72x::a[1] = a2p;

                /* UPA1 */
                /* update predictor pole a[0] */
                g72x::a[0] -= g72x::a[0] >> 8;
                if (dqsez != 0)
                {
                        if (pks1 == 0)
                                g72x::a[0] += 192;
                        else
                                g72x::a[0] -= 192;
                }
                /* LIMD */
                a1ul = 15360 - a2p;
                if (g72x::a[0] < -a1ul)
                        g72x::a[0] = -a1ul;
                else if (g72x::a[0] > a1ul)
                        g72x::a[0] = a1ul;

                /* UPB : update predictor zeros b[6] */
                for (cnt = 0; cnt < 6; cnt++) {
                        if (code_size == 5)             /* for 40Kbps G.723 */
                                g72x::b[cnt] -= g72x::b[cnt] >> 9;
                        else                    /* for G.721 and 24Kbps G.723 */
                                g72x::b[cnt] -= g72x::b[cnt] >> 8;
                        if (dq & 0x7FFF) {                      /* XOR */
                                if ((dq ^ g72x::dq[cnt]) >= 0)
                                        g72x::b[cnt] += 128;
                                else
                                        g72x::b[cnt] -= 128;
                        }
                }
        }

        for (cnt = 5; cnt > 0; cnt--)
                g72x::dq[cnt] = g72x::dq[cnt-1];
        /* FLOAT A : convert dq[0] to 4-bit exp, 6-bit mantissa f.p. */
        if (mag == 0) {
                g72x::dq[0] = (dq >= 0) ? 0x20 : 0xFC20;
        } else {
                exp = quan(mag, power2, 15);
                g72x::dq[0] = (dq >= 0) ?
                    (exp << 6) + ((mag << 6) >> exp) :
                    (exp << 6) + ((mag << 6) >> exp) - 0x400;
        }

        g72x::sr[1] = g72x::sr[0];
        /* FLOAT B : convert sr to 4-bit exp., 6-bit mantissa f.p. */
        if (sr == 0) {
                g72x::sr[0] = 0x20;
        } else if (sr > 0) {
                exp = quan(sr, power2, 15);
                g72x::sr[0] = (exp << 6) + ((sr << 6) >> exp);
        } else if (sr > -32768L) {
                mag = -sr;
                exp = quan(mag, power2, 15);
                g72x::sr[0] =  (exp << 6) + ((mag << 6) >> exp) - 0x400;
        } else
                g72x::sr[0] = 0xFC20;

        /* DELAY A */
        g72x::pk[1] = g72x::pk[0];
        g72x::pk[0] = pk0;

        /* TONE */
        if (tr == 1)            /* this sample has been treated as data */
                g72x::td = 0;      /* next one will be treated as voice */
        else if (a2p < -11776)  /* small sample-to-sample correlation */
                g72x::td = 1;      /* signal may be data */
        else                            /* signal is voice */
                g72x::td = 0;

        /*
         * Adaptation speed control.
         */
        g72x::dms += (fi - g72x::dms) >> 5;           /* FILTA */
        g72x::dml += (((fi << 2) - g72x::dml) >> 7);  /* FILTB */

        if (tr == 1)
                g72x::ap = 256;
        else if (y < 1536)                                      /* SUBTC */
                g72x::ap += (0x200 - g72x::ap) >> 4;
        else if (g72x::td == 1)
                g72x::ap += (0x200 - g72x::ap) >> 4;
        else if (abs((g72x::dms << 2) - g72x::dml) >=
            (g72x::dml >> 3))
                g72x::ap += (0x200 - g72x::ap) >> 4;
        else
                g72x::ap += (-g72x::ap) >> 4;
}

short g723_16::_dqlntab[4] = { 116, 365, 365, 116};
short g723_16::_witab[4] = {-704, 14048, 14048, -704};
short g723_16::_fitab[4] = {0, 0xE00, 0xE00, 0};
short g723_16::_qtab[1] = {261};

g723_16::g723_16() : g72x(), AudioCodec()
{
	memcpy(&info, &g723_2.info, sizeof(info));
}

g723_24::g723_24() : g72x(), AudioCodec()
{
        memcpy(&info, &g723_3.info, sizeof(info));
}

g723_40::g723_40() : g72x(), AudioCodec()
{
        memcpy(&info, &g723_5.info, sizeof(info));
}

Audio::Sample g723_16::decoder(int i)
{
        short           sezi, sei, sez, se;     /* ACCUM */
        short           y;                      /* MIX */
        short           sr;                     /* ADDB */
        short           dq;
        short           dqsez;

        i &= 0x03;                      /* mask to get proper bits */
        sezi = predictor_zero();
        sez = sezi >> 1;
        sei = sezi + predictor_pole();
        se = sei >> 1;                  /* se = estimated signal */


        y = step_size();       /* adaptive quantizer step size */
        dq = reconstruct(i & 0x02, _dqlntab[i], y); /* unquantize pred diff */

        sr = (dq < 0) ? (se - (dq & 0x3FFF)) : (se + dq); /* reconst. signal */

        dqsez = sr - se + sez;                  /* pole prediction diff. */

        update(2, y, _witab[i], _fitab[i], dq, sr, dqsez);

	return sr << 2;
}

unsigned char g723_16::encoder(Sample sl)
{
        short           sei, sezi, se, sez;     /* ACCUM */
        short           d;                      /* SUBTA */
        short           y;                      /* MIX */
        short           sr;                     /* ADDB */
        short           dqsez;                  /* ADDC */
        short           dq, i;

	sl >>= 2;

        sezi = predictor_zero();
        sez = sezi >> 1;
        sei = sezi + predictor_pole();
        se = sei >> 1;                  /* se = estimated signal */

        d = sl - se;                    /* d = estimation diff. */

        /* quantize prediction difference d */
        y = step_size();       /* quantizer step size */
        i = quantize(d, y, _qtab, 1);  /* i = ADPCM code */

              /* Since quantize() only produces a three level output
               * (1, 2, or 3), we must create the fourth one on our own
               */
        if (i == 3)                          /* i code for the zero region */
          if ((d & 0x8000) == 0)             /* If d > 0, i=3 isn't right... */
            i = 0;


        dq = reconstruct(i & 2, _dqlntab[i], y); /* quantized diff. */

        sr = (dq < 0) ? se - (dq & 0x3FFF) : se + dq; /* reconstructed signal */
        dqsez = sr + sez - se;          /* pole prediction diff. */

        update(2, y, _witab[i], _fitab[i], dq, sr, dqsez);

	return i;

}

unsigned g723_16::decode(Linear buffer, void *source, unsigned lsamples, bool buffered)
{
	unsigned char code, *dp = (unsigned char *)source;
	unsigned count = 0;

	while(lsamples > 3)
	{
		code = *(dp++);
		*(buffer++) = (code >> 6);
		*(buffer++) = (code >> 4) & 0x03;
		*(buffer++) = (code >> 2) & 0x03;
		*(buffer++) = code & 0x03;
		lsamples -= 4;
		count += 4;
	}
	return count;
}
	
unsigned g723_16::encode(Linear buffer, void *dest, unsigned lsamples, bool buffered)
{
	unsigned char *dp = (unsigned char *)dest, code;
	unsigned count = 0;

	while(lsamples > 3)
	{
		code = encoder(*(buffer++));
		code = code << 2 | encoder(*(buffer++));
		code = code << 2 | encoder(*(buffer++));
		code = code << 2 | encoder(*(buffer++));
		*(dp++) = code;
		count += 4;
		lsamples -= 4;
	}
	return count;
}

}