#define SIGN_BIT    (0x80)      /* Sign bit for a A-law byte. */
#define QUANT_MASK  (0xf)       /* Quantization field mask. */
#define NSEGS       (8)         /* Number of A-law segments. */
#define SEG_SHIFT   (4)         /* Left shift for segment number. */
#define SEG_MASK    (0x70)      /* Segment field mask. */

long hcoding;
long hdecoding;
int pcm_val;

static short seg_end[8] = {0xFF, 0x1FF, 0x3FF, 0x7FF,
                           0xFFF, 0x1FFF, 0x3FFF, 0x7FFF};

static int  search(int val,short *table,int size)
{
   int i;

   for(i=0;i<size;i++)
   {
      if(val<=*table++)
         return(i);
   }
   return (size);
}

unsigned char linear2alaw(int pcm_val)    /* 2's complement (16-bit range) */
{
   int  mask;
   int  seg;
   unsigned char    aval;

   if (pcm_val>=0)
      mask=0x80;        /* sign (7th) bit = 1 */
   else
   {
      mask=0x00;        /* sign bit = 0 */
      pcm_val=pcm_val&0x7fff;
   }


/* Convert the scaled magnitude to segment number. */
   seg=search(pcm_val, seg_end, 8);

/* Combine the sign, segment, and quantization bits. */
   if(seg>=8)       /* out of range, return maximum value. */
      return (0x7F^mask);
   else
   {
      aval=seg<<SEG_SHIFT;
      if(seg<2)
         aval|=(pcm_val>>4)&QUANT_MASK;
      else
         aval|=(pcm_val>>(seg+3))&QUANT_MASK;
      return(aval+mask);
   }
}

long  alaw2linear(unsigned char a_val)
{
   long t;
   int  seg;                

   t=(a_val&QUANT_MASK)<<4;
   seg=((unsigned)a_val&SEG_MASK)>>SEG_SHIFT;
   switch(seg)
   {
      case 0:
         t+=8;
         break;

      case 1:
         t+=0x108;
         break;

      default:
         t+=0x108;
         t<<=(seg-1);
   }
   return((a_val&SIGN_BIT)?t:(t+0x8000));
}

main()
{
   pcm_val=0x8118;
   hcoding=linear2alaw(pcm_val);
   hdecoding=alaw2linear(hcoding);
}