workbench/classes/datatypes/wav/wave_alaw.c

   1 /*
   2  *      wave.datatype
   3  *      (c) Fredrik Wikstrom
   4  */
   5
   6 #include "wave_alaw.h"
   7
   8 static WORD decode_alaw (UBYTE a_val);
   9 static WORD decode_mulaw(UBYTE u_val);
  10
  11 DEC_SETUPPROTO(SetupALaw) {
  12         struct WaveFormatEx * fmt;
  13         fmt = data->fmt;
  14         if (fmt->extraSize != 0)
  15                 return NOTOK;
  16         if (fmt->bitsPerSample != 8)
  17                 return ERROR_NOT_IMPLEMENTED;
  18         data->blockFrames = 1;
  19         return OK;
  20 }
  21
  22 DECODERPROTO(DecodeALaw) {
  23         LONG frame,chan;
  24         for (frame=0;frame<numFrames;frame++) {
  25                 for (chan=0;chan<fmt->numChannels;chan++) {
  26                         *Dst[chan]++ = decode_alaw(*Src++) >> 8;
  27                 }
  28         }
  29         return numFrames;
  30 }
  31
  32 DECODERPROTO(DecodeMuLaw) {
  33         LONG frame,chan;
  34         for (frame=0;frame<numFrames;frame++) {
  35                 for (chan=0;chan<fmt->numChannels;chan++) {
  36                         *Dst[chan]++ = decode_mulaw(*Src++) >> 8;
  37                 }
  38         }
  39         return numFrames;
  40 }
  41
  42 #define SIGN_BIT        (0x80)          /* Sign bit for a A-law byte. */
  43 #define QUANT_MASK      (0xf)           /* Quantization field mask. */
  44 #define SEG_SHIFT       (4)             /* Left shift for segment number. */
  45 #define SEG_MASK        (0x70)          /* Segment field mask. */
  46 #define BIAS            (0x84)          /* Bias for linear code. */
  47
  48 static WORD decode_alaw (UBYTE a_val) {
  49         WORD t;
  50         WORD seg;
  51
  52         a_val ^= 0x55;
  53
  54         t = (a_val & QUANT_MASK) << 4;
  55         seg = ((unsigned)a_val & SEG_MASK) >> SEG_SHIFT;
  56         switch (seg) {
  57         case 0:
  58                 t += 8;
  59                 break;
  60         case 1:
  61                 t += 0x108;
  62                 break;
  63         default:
  64                 t += 0x108;
  65                 t <<= seg - 1;
  66         }
  67         return ((a_val & SIGN_BIT) ? t : -t);
  68 }
  69
  70 static WORD decode_mulaw(UBYTE u_val) {
  71         WORD t;
  72
  73         /* Complement to obtain normal u-law value. */
  74         u_val = ~u_val;
  75
  76         /*
  77          * Extract and bias the quantization bits. Then
  78          * shift up by the segment number and subtract out the bias.
  79          */
  80         t = ((u_val & QUANT_MASK) << 3) + BIAS;
  81         t <<= ((unsigned)u_val & SEG_MASK) >> SEG_SHIFT;
  82
  83         return ((u_val & SIGN_BIT) ? (BIAS - t) : (t - BIAS));
  84 }