g722.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	g722_decode_state_t
struct	g722_encode_state_t

Macros
#define	INT16_MAX   32767
#define	INT16_MIN   (-32768)

Enumerations
enum	{ G722_SAMPLE_RATE_8000 = 0x0001, G722_PACKED = 0x0002 }

Functions
int	g722_decode (g722_decode_state_t *s, int16_t amp[], const uint8_t g722_data[], int len)
g722_decode_state_t *	g722_decode_init (g722_decode_state_t *s, int rate, int options)
int	g722_decode_release (g722_decode_state_t *s)
int	g722_encode (g722_encode_state_t *s, uint8_t g722_data[], const int16_t amp[], int len)
g722_encode_state_t *	g722_encode_init (g722_encode_state_t *s, int rate, int options)
int	g722_encode_release (g722_encode_state_t *s)

Macro Definition Documentation

INT16_MAX

#define INT16_MAX   32767

Definition at line 50 of file g722.h.

Referenced by saturate().

INT16_MIN

#define INT16_MIN   (-32768)

Definition at line 53 of file g722.h.

Referenced by saturate().

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
G722_SAMPLE_RATE_8000
G722_PACKED

Definition at line 43 of file g722.h.

{
 G722_SAMPLE_RATE_8000 = 0x0001,
 G722_PACKED = 0x0002
};

Function Documentation

g722_decode()

int g722_decode	(	g722_decode_state_t *	s,
		int16_t	amp[],
		const uint8_t	g722_data[],
		int	len
	)

Definition at line 186 of file g722_decode.c.

References g722_decode_state_t::band, g722_decode_state_t::bits_per_sample, block4(), g722_decode_state_t::det, g722_decode_state_t::eight_k, g722_decode_state_t::in_bits, g722_decode_state_t::in_buffer, g722_decode_state_t::itu_test_mode, len(), g722_decode_state_t::nb, g722_decode_state_t::packed, g722_decode_state_t::s, and g722_decode_state_t::x.

Referenced by g722tolin_framein().

{
 static const int wl[8] = {-60, -30, 58, 172, 334, 538, 1198, 3042 };
 static const int rl42[16] = {0, 7, 6, 5, 4, 3, 2, 1, 7, 6, 5, 4, 3, 2, 1, 0 };
 static const int ilb[32] =
 {
 2048, 2093, 2139, 2186, 2233, 2282, 2332,
 2383, 2435, 2489, 2543, 2599, 2656, 2714,
 2774, 2834, 2896, 2960, 3025, 3091, 3158,
 3228, 3298, 3371, 3444, 3520, 3597, 3676,
 3756, 3838, 3922, 4008
 };
 static const int wh[3] = {0, -214, 798};
 static const int rh2[4] = {2, 1, 2, 1};
 static const int qm2[4] = {-7408, -1616, 7408, 1616};
 static const int qm4[16] =
 {
 0, -20456, -12896, -8968,
 -6288, -4240, -2584, -1200,
 20456, 12896, 8968, 6288,
 4240, 2584, 1200, 0
 };
 static const int qm5[32] =
 {
 -280, -280, -23352, -17560,
 -14120, -11664, -9752, -8184,
 -6864, -5712, -4696, -3784,
 -2960, -2208, -1520, -880,
 23352, 17560, 14120, 11664,
 9752, 8184, 6864, 5712,
 4696, 3784, 2960, 2208,
 1520, 880, 280, -280
 };
 static const int qm6[64] =
 {
 -136, -136, -136, -136,
 -24808, -21904, -19008, -16704,
 -14984, -13512, -12280, -11192,
 -10232, -9360, -8576, -7856,
 -7192, -6576, -6000, -5456,
 -4944, -4464, -4008, -3576,
 -3168, -2776, -2400, -2032,
 -1688, -1360, -1040, -728,
 24808, 21904, 19008, 16704,
 14984, 13512, 12280, 11192,
 10232, 9360, 8576, 7856,
 7192, 6576, 6000, 5456,
 4944, 4464, 4008, 3576,
 3168, 2776, 2400, 2032,
 1688, 1360, 1040, 728,
 432, 136, -432, -136
 };
 static const int qmf_coeffs[12] =
 {
 3, -11, 12, 32, -210, 951, 3876, -805, 362, -156, 53, -11,
 };

 int dlowt;
 int rlow;
 int ihigh;
 int dhigh;
 int rhigh;
 int xout1;
 int xout2;
 int wd1;
 int wd2;
 int wd3;
 int code;
 int outlen;
 int i;
 int j;

 outlen = 0;
 rhigh = 0;
 for (j = 0; j < len; )
 {
 if (s->packed)
 {
 /* Unpack the code bits */
 if (s->in_bits < s->bits_per_sample)
 {
 s->in_buffer |= (g722_data[j++] << s->in_bits);
 s->in_bits += 8;
 }
 code = s->in_buffer & ((1 << s->bits_per_sample) - 1);
 s->in_buffer >>= s->bits_per_sample;
 s->in_bits -= s->bits_per_sample;
 }
 else
 {
 code = g722_data[j++];
 }

 switch (s->bits_per_sample)
 {
 default:
 case 8:
 wd1 = code & 0x3F;
 ihigh = (code >> 6) & 0x03;
 wd2 = qm6[wd1];
 wd1 >>= 2;
 break;
 case 7:
 wd1 = code & 0x1F;
 ihigh = (code >> 5) & 0x03;
 wd2 = qm5[wd1];
 wd1 >>= 1;
 break;
 case 6:
 wd1 = code & 0x0F;
 ihigh = (code >> 4) & 0x03;
 wd2 = qm4[wd1];
 break;
 }
 /* Block 5L, LOW BAND INVQBL */
 wd2 = (s->band[0].det*wd2) >> 15;
 /* Block 5L, RECONS */
 rlow = s->band[0].s + wd2;
 /* Block 6L, LIMIT */
 if (rlow > 16383)
 rlow = 16383;
 else if (rlow < -16384)
 rlow = -16384;

 /* Block 2L, INVQAL */
 wd2 = qm4[wd1];
 dlowt = (s->band[0].det*wd2) >> 15;

 /* Block 3L, LOGSCL */
 wd2 = rl42[wd1];
 wd1 = (s->band[0].nb*127) >> 7;
 wd1 += wl[wd2];
 if (wd1 < 0)
 wd1 = 0;
 else if (wd1 > 18432)
 wd1 = 18432;
 s->band[0].nb = wd1;

 /* Block 3L, SCALEL */
 wd1 = (s->band[0].nb >> 6) & 31;
 wd2 = 8 - (s->band[0].nb >> 11);
 wd3 = (wd2 < 0) ? (ilb[wd1] << -wd2) : (ilb[wd1] >> wd2);
 s->band[0].det = wd3 << 2;

 block4(s, 0, dlowt);

 if (!s->eight_k)
 {
 /* Block 2H, INVQAH */
 wd2 = qm2[ihigh];
 dhigh = (s->band[1].det*wd2) >> 15;
 /* Block 5H, RECONS */
 rhigh = dhigh + s->band[1].s;
 /* Block 6H, LIMIT */
 if (rhigh > 16383)
 rhigh = 16383;
 else if (rhigh < -16384)
 rhigh = -16384;

 /* Block 2H, INVQAH */
 wd2 = rh2[ihigh];
 wd1 = (s->band[1].nb*127) >> 7;
 wd1 += wh[wd2];
 if (wd1 < 0)
 wd1 = 0;
 else if (wd1 > 22528)
 wd1 = 22528;
 s->band[1].nb = wd1;

 /* Block 3H, SCALEH */
 wd1 = (s->band[1].nb >> 6) & 31;
 wd2 = 10 - (s->band[1].nb >> 11);
 wd3 = (wd2 < 0) ? (ilb[wd1] << -wd2) : (ilb[wd1] >> wd2);
 s->band[1].det = wd3 << 2;

 block4(s, 1, dhigh);
 }

 if (s->itu_test_mode)
 {
 amp[outlen++] = (int16_t) (rlow << 1);
 amp[outlen++] = (int16_t) (rhigh << 1);
 }
 else
 {
 if (s->eight_k)
 {
 amp[outlen++] = (int16_t) (rlow << 1);
 }
 else
 {
 /* Apply the receive QMF */
 for (i = 0; i < 22; i++)
 s->x[i] = s->x[i + 2];
 s->x[22] = rlow + rhigh;
 s->x[23] = rlow - rhigh;

 xout1 = 0;
 xout2 = 0;
 for (i = 0; i < 12; i++)
 {
 xout2 += s->x[2*i]*qmf_coeffs[i];
 xout1 += s->x[2*i + 1]*qmf_coeffs[11 - i];
 }
 amp[outlen++] = (int16_t) (xout1 >> 11);
 amp[outlen++] = (int16_t) (xout2 >> 11);
 }
 }
 }
 return outlen;
}

g722_decode_init()

g722_decode_state_t* g722_decode_init	(	g722_decode_state_t *	s,
		int	rate,
		int	options
	)

Definition at line 153 of file g722_decode.c.

References g722_decode_state_t::band, g722_decode_state_t::bits_per_sample, g722_decode_state_t::det, g722_decode_state_t::eight_k, FALSE, G722_PACKED, G722_SAMPLE_RATE_8000, malloc(), NULL, g722_decode_state_t::packed, and TRUE.

Referenced by g722tolin16_new(), and g722tolin_new().

{
 if (s == NULL)
 {
 if ((s = (g722_decode_state_t *) malloc(sizeof(*s))) == NULL)
 return NULL;
 }
 memset(s, 0, sizeof(*s));
 if (rate == 48000)
 s->bits_per_sample = 6;
 else if (rate == 56000)
 s->bits_per_sample = 7;
 else
 s->bits_per_sample = 8;
 if ((options & G722_SAMPLE_RATE_8000))
 s->eight_k = TRUE;
 if ((options & G722_PACKED) && s->bits_per_sample != 8)
 s->packed = TRUE;
 else
 s->packed = FALSE;
 s->band[0].det = 32;
 s->band[1].det = 8;
 return s;
}

g722_decode_release()

int g722_decode_release

(

g722_decode_state_t *

s

)

Definition at line 179 of file g722_decode.c.

References free().

{
 free(s);
 return 0;
}

g722_encode()

int g722_encode	(	g722_encode_state_t *	s,
		uint8_t	g722_data[],
		const int16_t	amp[],
		int	len
	)

Definition at line 185 of file g722_encode.c.

References g722_encode_state_t::band, g722_encode_state_t::bits_per_sample, block4(), g722_encode_state_t::det, g722_encode_state_t::eight_k, el, g722_encode_state_t::itu_test_mode, len(), g722_encode_state_t::nb, g722_encode_state_t::out_bits, g722_encode_state_t::out_buffer, g722_encode_state_t::packed, g722_encode_state_t::s, saturate(), and g722_encode_state_t::x.

Referenced by lintog722_framein().

{
 static const int q6[32] =
 {
 0, 35, 72, 110, 150, 190, 233, 276,
 323, 370, 422, 473, 530, 587, 650, 714,
 786, 858, 940, 1023, 1121, 1219, 1339, 1458,
 1612, 1765, 1980, 2195, 2557, 2919, 0, 0
 };
 static const int iln[32] =
 {
 0, 63, 62, 31, 30, 29, 28, 27,
 26, 25, 24, 23, 22, 21, 20, 19,
 18, 17, 16, 15, 14, 13, 12, 11,
 10, 9, 8, 7, 6, 5, 4, 0
 };
 static const int ilp[32] =
 {
 0, 61, 60, 59, 58, 57, 56, 55,
 54, 53, 52, 51, 50, 49, 48, 47,
 46, 45, 44, 43, 42, 41, 40, 39,
 38, 37, 36, 35, 34, 33, 32, 0
 };
 static const int wl[8] =
 {
 -60, -30, 58, 172, 334, 538, 1198, 3042
 };
 static const int rl42[16] =
 {
 0, 7, 6, 5, 4, 3, 2, 1, 7, 6, 5, 4, 3, 2, 1, 0
 };
 static const int ilb[32] =
 {
 2048, 2093, 2139, 2186, 2233, 2282, 2332,
 2383, 2435, 2489, 2543, 2599, 2656, 2714,
 2774, 2834, 2896, 2960, 3025, 3091, 3158,
 3228, 3298, 3371, 3444, 3520, 3597, 3676,
 3756, 3838, 3922, 4008
 };
 static const int qm4[16] =
 {
 0, -20456, -12896, -8968,
 -6288, -4240, -2584, -1200,
 20456, 12896, 8968, 6288,
 4240, 2584, 1200, 0
 };
 static const int qm2[4] =
 {
 -7408, -1616, 7408, 1616
 };
 static const int qmf_coeffs[12] =
 {
 3, -11, 12, 32, -210, 951, 3876, -805, 362, -156, 53, -11,
 };
 static const int ihn[3] = {0, 1, 0};
 static const int ihp[3] = {0, 3, 2};
 static const int wh[3] = {0, -214, 798};
 static const int rh2[4] = {2, 1, 2, 1};

 int dlow;
 int dhigh;
 int el;
 int wd;
 int wd1;
 int ril;
 int wd2;
 int il4;
 int ih2;
 int wd3;
 int eh;
 int mih;
 int i;
 int j;
 /* Low and high band PCM from the QMF */
 int xlow;
 int xhigh;
 int g722_bytes;
 /* Even and odd tap accumulators */
 int sumeven;
 int sumodd;
 int ihigh;
 int ilow;
 int code;

 g722_bytes = 0;
 xhigh = 0;
 for (j = 0; j < len; )
 {
 if (s->itu_test_mode)
 {
 xlow =
 xhigh = amp[j++] >> 1;
 }
 else
 {
 if (s->eight_k)
 {
 xlow = amp[j++] >> 1;
 }
 else
 {
 /* Apply the transmit QMF */
 /* Shuffle the buffer down */
 for (i = 0; i < 22; i++)
 s->x[i] = s->x[i + 2];
 s->x[22] = amp[j++];
 s->x[23] = amp[j++];

 /* Discard every other QMF output */
 sumeven = 0;
 sumodd = 0;
 for (i = 0; i < 12; i++)
 {
 sumodd += s->x[2*i]*qmf_coeffs[i];
 sumeven += s->x[2*i + 1]*qmf_coeffs[11 - i];
 }
 xlow = (sumeven + sumodd) >> 14;
 xhigh = (sumeven - sumodd) >> 14;
 }
 }
 /* Block 1L, SUBTRA */
 el = saturate(xlow - s->band[0].s);

 /* Block 1L, QUANTL */
 wd = (el >= 0) ? el : -(el + 1);

 for (i = 1; i < 30; i++)
 {
 wd1 = (q6[i]*s->band[0].det) >> 12;
 if (wd < wd1)
 break;
 }
 ilow = (el < 0) ? iln[i] : ilp[i];

 /* Block 2L, INVQAL */
 ril = ilow >> 2;
 wd2 = qm4[ril];
 dlow = (s->band[0].det*wd2) >> 15;

 /* Block 3L, LOGSCL */
 il4 = rl42[ril];
 wd = (s->band[0].nb*127) >> 7;
 s->band[0].nb = wd + wl[il4];
 if (s->band[0].nb < 0)
 s->band[0].nb = 0;
 else if (s->band[0].nb > 18432)
 s->band[0].nb = 18432;

 /* Block 3L, SCALEL */
 wd1 = (s->band[0].nb >> 6) & 31;
 wd2 = 8 - (s->band[0].nb >> 11);
 wd3 = (wd2 < 0) ? (ilb[wd1] << -wd2) : (ilb[wd1] >> wd2);
 s->band[0].det = wd3 << 2;

 block4(s, 0, dlow);

 if (s->eight_k)
 {
 /* Just leave the high bits as zero */
 code = (0xC0 | ilow) >> (8 - s->bits_per_sample);
 }
 else
 {
 /* Block 1H, SUBTRA */
 eh = saturate(xhigh - s->band[1].s);

 /* Block 1H, QUANTH */
 wd = (eh >= 0) ? eh : -(eh + 1);
 wd1 = (564*s->band[1].det) >> 12;
 mih = (wd >= wd1) ? 2 : 1;
 ihigh = (eh < 0) ? ihn[mih] : ihp[mih];

 /* Block 2H, INVQAH */
 wd2 = qm2[ihigh];
 dhigh = (s->band[1].det*wd2) >> 15;

 /* Block 3H, LOGSCH */
 ih2 = rh2[ihigh];
 wd = (s->band[1].nb*127) >> 7;
 s->band[1].nb = wd + wh[ih2];
 if (s->band[1].nb < 0)
 s->band[1].nb = 0;
 else if (s->band[1].nb > 22528)
 s->band[1].nb = 22528;

 /* Block 3H, SCALEH */
 wd1 = (s->band[1].nb >> 6) & 31;
 wd2 = 10 - (s->band[1].nb >> 11);
 wd3 = (wd2 < 0) ? (ilb[wd1] << -wd2) : (ilb[wd1] >> wd2);
 s->band[1].det = wd3 << 2;

 block4(s, 1, dhigh);
 code = ((ihigh << 6) | ilow) >> (8 - s->bits_per_sample);
 }

 if (s->packed)
 {
 /* Pack the code bits */
 s->out_buffer |= (code << s->out_bits);
 s->out_bits += s->bits_per_sample;
 if (s->out_bits >= 8)
 {
 g722_data[g722_bytes++] = (uint8_t) (s->out_buffer & 0xFF);
 s->out_bits -= 8;
 s->out_buffer >>= 8;
 }
 }
 else
 {
 g722_data[g722_bytes++] = (uint8_t) code;
 }
 }
 return g722_bytes;
}

g722_encode_init()

g722_encode_state_t* g722_encode_init	(	g722_encode_state_t *	s,
		int	rate,
		int	options
	)

Definition at line 152 of file g722_encode.c.

References g722_encode_state_t::band, g722_encode_state_t::bits_per_sample, g722_encode_state_t::det, g722_encode_state_t::eight_k, FALSE, G722_PACKED, G722_SAMPLE_RATE_8000, malloc(), NULL, g722_encode_state_t::packed, and TRUE.

Referenced by lin16tog722_new(), and lintog722_new().

{
 if (s == NULL)
 {
 if ((s = (g722_encode_state_t *) malloc(sizeof(*s))) == NULL)
 return NULL;
 }
 memset(s, 0, sizeof(*s));
 if (rate == 48000)
 s->bits_per_sample = 6;
 else if (rate == 56000)
 s->bits_per_sample = 7;
 else
 s->bits_per_sample = 8;
 if ((options & G722_SAMPLE_RATE_8000))
 s->eight_k = TRUE;
 if ((options & G722_PACKED) && s->bits_per_sample != 8)
 s->packed = TRUE;
 else
 s->packed = FALSE;
 s->band[0].det = 32;
 s->band[1].det = 8;
 return s;
}

g722_encode_release()

int g722_encode_release

(

g722_encode_state_t *

s

)

Definition at line 178 of file g722_encode.c.

References free().

{
 free(s);
 return 0;
}