//==========================================================================;
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
// KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
// PURPOSE.
//
// Copyright (c) 1993-1996 Microsoft Corporation
//
//--------------------------------------------------------------------------;
//
// gentable.c
//
// Description:
// This is a utility program to generate various tables in the
// form of 'C' source code. Portions of some of these tables can
// be pasted into codec source code. The output is to stdio
// and can be redirected into a file. Portions of the file can
// then be cut and pasted into another 'C' source file as necessary.
//
//==========================================================================;
#include <stdio.h>
//--------------------------------------------------------------------------;
//
// Name:
// UlawToAlawTable
//
//
// Description:
/* This table was copied directly from the G.711 specification. Using
the G.711 spec terminology, this table converts u-law decoder output
value numbers to A-law decoder output value numbers.
*/
//
// Arguments:
//
//
// Return:
//
//
// Notes:
//
//
// History:
// 08/01/93 Created.
//
//
//--------------------------------------------------------------------------;
unsigned char UlawToAlawTable[128] =
{
1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,
9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,
27,29,31,
33,34,35,36,37,38,39,40,41,42,43,44,
46,
48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,
64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,
81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,
100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,
120,121,122,123,124,125,126,127,128
};
//--------------------------------------------------------------------------;
//
// Name:
// AlawToUlawTable
//
//
// Description:
/* This table was copied directly from the G.711 specification. Using
the G.711 spec terminology, this table converts A-law decoder output
value numbers to u-law decoder output value numbers. A-law decoder
output value numbers range from 1 to 128, so AlawToUlawTable[0] is
unused. Note that u-law decoder output value numbers range from
0 to 127.
*/
//
// Arguments:
//
//
// Return:
//
//
// Notes:
//
//
// History:
// 08/01/93 Created.
//
//
//--------------------------------------------------------------------------;
unsigned char AlawToUlawTable[129] =
{
0, // this first entry not used
1,3,5,7,9,11,13,
15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
32,32,33,33,34,34,35,35,
36,37,38,39,40,41,42,43,44,45,46,47,
48,48,49,49,
50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,
64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,
79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,
100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,
116,117,118,119,120,121,122,123,124,125,126,127
};
short DecodeTable[256];
//
// Our main procedure.
//
void main()
{
short i,j;
short SegBase[16];
short IntervalStep[16];
short Sample;
//
// This generates a decode table for A-law. The resulting
// table can be used to convert an A-law character to
// a 16-bit PCM value.
//
// These seg base values and interval steps are based directly
// on the G.711 A-law spec. They correspond to 13-bit PCM data.
SegBase[ 0] = -1; IntervalStep[ 0] = -2;
SegBase[ 1] = -33; IntervalStep[ 1] = -2;
SegBase[ 2] = -66; IntervalStep[ 2] = -4;
SegBase[ 3] = -132; IntervalStep[ 3] = -8;
SegBase[ 4] = -264; IntervalStep[ 4] = -16;
SegBase[ 5] = -528; IntervalStep[ 5] = -32;
SegBase[ 6] = -1056; IntervalStep[ 6] = -64;
SegBase[ 7] = -2112; IntervalStep[ 7] = -128;
SegBase[ 8] = 1; IntervalStep[ 8] = 2;
SegBase[ 9] = 33; IntervalStep[ 9] = 2;
SegBase[10] = 66; IntervalStep[10] = 4;
SegBase[11] = 132; IntervalStep[11] = 8;
SegBase[12] = 264; IntervalStep[12] = 16;
SegBase[13] = 528; IntervalStep[13] = 32;
SegBase[14] = 1056; IntervalStep[14] = 64;
SegBase[15] = 2112; IntervalStep[15] = 128;
printf("\n\n\n\n\n// A-law decode table:\n\n");
for (i=0; i<16; i++)
for (j=0; j<16; j++)
{
Sample = SegBase[i^0x05] + IntervalStep[i^0x05]*(j^0x05);
// Sample is a 13-bit signed PCM value.
// In our table, we'll convert it to 16-bit. The
// generated comment will indicate the 13-bit value.
printf( "\t%6d,\t\t// y[%02x]= %6d\n",
Sample << 3,
i*16 + j,
Sample);
}
//
// This generates a decode table for u-law. The resulting
// table can be used to convert a u-law character to
// a 16-bit PCM value.
//
// These seg base values and interval steps are based directly
// on the G.711 A-law spec. They correspond to 14-bit PCM data.
SegBase[ 0] = -8031; IntervalStep[ 0] = 256;
SegBase[ 1] = -3999; IntervalStep[ 1] = 128;
SegBase[ 2] = -1983; IntervalStep[ 2] = 64;
SegBase[ 3] = -975; IntervalStep[ 3] = 32;
SegBase[ 4] = -471; IntervalStep[ 4] = 16;
SegBase[ 5] = -219; IntervalStep[ 5] = 8;
SegBase[ 6] = -93; IntervalStep[ 6] = 4;
SegBase[ 7] = -30; IntervalStep[ 7] = 2;
SegBase[ 8] = 8031; IntervalStep[ 8] = -256;
SegBase[ 9] = 3999; IntervalStep[ 9] = -128;
SegBase[10] = 1983; IntervalStep[10] = -64;
SegBase[11] = 975; IntervalStep[11] = -32;
SegBase[12] = 471; IntervalStep[12] = -16;
SegBase[13] = 219; IntervalStep[13] = -8;
SegBase[14] = 93; IntervalStep[14] = -4;
SegBase[15] = 30; IntervalStep[15] = -2;
printf("\n\n\n\n\n// u-law decode table:\n\n");
for (i=0; i<16; i++)
for (j=0; j<16; j++)
{
Sample = SegBase[i] + IntervalStep[i]*j;
// Sample is a 14-bit signed PCM value.
// In our table, we'll convert it to 16-bit. The
// generated comment will indicate the 14-bit value.
printf( "\t%6d,\t\t// y[%02x]= %6d\n",
Sample << 2,
i*16 + j,
Sample);
}
//
// This generates a conversion table from A-law chars
// to u-law chars. The AlawToUlawTable above converts
// decoder output value numbers, which is not quite what
// we want. Using that table, this routine will generate
// 'C' source code for a table that converts directly from
// A-law chars to u-law chars.
//
printf("\n\n\n\n\n// A-law to u-law char conversion table:\n\n");
for (i=0; i<256; i++) // i counts thru all A-law chars
{
// Here is the process to go from an A-law char
// to a u-law char.
// 1. convert from A-law char to A-law decoder
// output value number. from observing the tables
// in the G.711 spec it can be seen that this is
// done by inverting the even bits and dropping the
// sign bit of the A-law char and then adding 1.
// 2. using the AlawToUlawTable above, convert from
// the A-law decoder output value number to the
// corresponding u-law output value number.
// 3. convert from u-law decoder output value
// number to u-law char. from observing the tables
// in the G.711 spec it can be seen that this is
// done by inverting the 7 LSBs of the u-law
// decoder output value number.
// 4. apply polarity to the u-law char. that is,
// set the sign bit of the u-law char the same
// as the sign bit of the original A-law char.
j = i; // j starts of as original A-law char
// Step 1:
j = ((i^0x55) & 0x7F) + 1;
// Step 2:
j = AlawToUlawTable[j];
// Step 3:
j = (j ^ 0x7F);
// Step 4:
j = j | (i & 0x80); // j ends as corresponding u-law char
// Now i is an A-law char and j is the corresponding u-law char
printf( "\t0x%02x,\t\t// A-law[%02x] ==> u-law[%02x]\n",
j,
i,
j);
}
//
// This generates a conversion table from u-law chars
// to A-law chars. The UlawToAlawTable above converts
// decoder output value numbers, which is not quite what
// we want. Using that table, this routine will generate
// 'C' source code for a table that converts directly from
// u-law chars to A-law chars.
//
printf("\n\n\n\n\n// u-law to A-law char conversion table:\n\n");
for (i=0; i<256; i++) // i counts thru all U-law chars
{
// Here is the process to go from a u-law char
// to a A-law char.
// 1. convert from u-law char to u-law decoder
// output value number. from observing the tables
// in the G.711 spec it can be seen that this is
// done by dropping the sign bit of the u-law
// char and then inverting the 7 LSBs.
// 2. using the UlawToAlawTable above, convert from
// the u-law decoder output value number to the
// corresponding A-law output value number.
// 3. convert from A-law decoder output value
// number to A-law char. from observing the tables
// in the G.711 spec it can be seen that this is
// done by subtracting 1 from the A-law decoder output
// value number and inverting the even bits.
// 4. apply polarity to the A-law char. that is,
// set the sign bit of the A-law char the same
// as the sign bit of the original u-law char.
j = i; // j starts of as original u-law char
// Step 1:
j = (i & 0x7F) ^ 0x7F;
// Step 2:
j = UlawToAlawTable[j];
// Step 3:
j = (j - 1)^0x55;
// Step 4:
j = j | (i & 0x80); // j ends as corresponding A-law char
// Now i is a u-law char and j is the corresponding A-law char
printf( "\t0x%02x,\t\t// u-law[%02x] ==> A-law[%02x]\n",
j,
i,
j);
}
return;
}