OpenAL32/sample_cvt.c

   1
   2 #include "config.h"
   3
   4 #include "sample_cvt.h"
   5
   6 #include "AL/al.h"
   7 #include "alu.h"
   8 #include "alBuffer.h"
   9
  10
  11 /* IMA ADPCM Stepsize table */
  12 static const int IMAStep_size[89] = {
  13        7,    8,    9,   10,   11,   12,   13,   14,   16,   17,   19,
  14       21,   23,   25,   28,   31,   34,   37,   41,   45,   50,   55,
  15       60,   66,   73,   80,   88,   97,  107,  118,  130,  143,  157,
  16      173,  190,  209,  230,  253,  279,  307,  337,  371,  408,  449,
  17      494,  544,  598,  658,  724,  796,  876,  963, 1060, 1166, 1282,
  18     1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327, 3660,
  19     4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493,10442,
  20    11487,12635,13899,15289,16818,18500,20350,22358,24633,27086,29794,
  21    32767
  22 };
  23
  24 /* IMA4 ADPCM Codeword decode table */
  25 static const int IMA4Codeword[16] = {
  26     1, 3, 5, 7, 9, 11, 13, 15,
  27    -1,-3,-5,-7,-9,-11,-13,-15,
  28 };
  29
  30 /* IMA4 ADPCM Step index adjust decode table */
  31 static const int IMA4Index_adjust[16] = {
  32    -1,-1,-1,-1, 2, 4, 6, 8,
  33    -1,-1,-1,-1, 2, 4, 6, 8
  34 };
  35
  36
  37 /* MSADPCM Adaption table */
  38 static const int MSADPCMAdaption[16] = {
  39     230, 230, 230, 230, 307, 409, 512, 614,
  40     768, 614, 512, 409, 307, 230, 230, 230
  41 };
  42
  43 /* MSADPCM Adaption Coefficient tables */
  44 static const int MSADPCMAdaptionCoeff[7][2] = {
  45     { 256,    0 },
  46     { 512, -256 },
  47     {   0,    0 },
  48     { 192,   64 },
  49     { 240,    0 },
  50     { 460, -208 },
  51     { 392, -232 }
  52 };
  53
  54
  55 /* A quick'n'dirty lookup table to decode a muLaw-encoded byte sample into a
  56  * signed 16-bit sample */
  57 const ALshort muLawDecompressionTable[256] = {
  58     -32124,-31100,-30076,-29052,-28028,-27004,-25980,-24956,
  59     -23932,-22908,-21884,-20860,-19836,-18812,-17788,-16764,
  60     -15996,-15484,-14972,-14460,-13948,-13436,-12924,-12412,
  61     -11900,-11388,-10876,-10364, -9852, -9340, -8828, -8316,
  62      -7932, -7676, -7420, -7164, -6908, -6652, -6396, -6140,
  63      -5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092,
  64      -3900, -3772, -3644, -3516, -3388, -3260, -3132, -3004,
  65      -2876, -2748, -2620, -2492, -2364, -2236, -2108, -1980,
  66      -1884, -1820, -1756, -1692, -1628, -1564, -1500, -1436,
  67      -1372, -1308, -1244, -1180, -1116, -1052,  -988,  -924,
  68       -876,  -844,  -812,  -780,  -748,  -716,  -684,  -652,
  69       -620,  -588,  -556,  -524,  -492,  -460,  -428,  -396,
  70       -372,  -356,  -340,  -324,  -308,  -292,  -276,  -260,
  71       -244,  -228,  -212,  -196,  -180,  -164,  -148,  -132,
  72       -120,  -112,  -104,   -96,   -88,   -80,   -72,   -64,
  73        -56,   -48,   -40,   -32,   -24,   -16,    -8,     0,
  74      32124, 31100, 30076, 29052, 28028, 27004, 25980, 24956,
  75      23932, 22908, 21884, 20860, 19836, 18812, 17788, 16764,
  76      15996, 15484, 14972, 14460, 13948, 13436, 12924, 12412,
  77      11900, 11388, 10876, 10364,  9852,  9340,  8828,  8316,
  78       7932,  7676,  7420,  7164,  6908,  6652,  6396,  6140,
  79       5884,  5628,  5372,  5116,  4860,  4604,  4348,  4092,
  80       3900,  3772,  3644,  3516,  3388,  3260,  3132,  3004,
  81       2876,  2748,  2620,  2492,  2364,  2236,  2108,  1980,
  82       1884,  1820,  1756,  1692,  1628,  1564,  1500,  1436,
  83       1372,  1308,  1244,  1180,  1116,  1052,   988,   924,
  84        876,   844,   812,   780,   748,   716,   684,   652,
  85        620,   588,   556,   524,   492,   460,   428,   396,
  86        372,   356,   340,   324,   308,   292,   276,   260,
  87        244,   228,   212,   196,   180,   164,   148,   132,
  88        120,   112,   104,    96,    88,    80,    72,    64,
  89         56,    48,    40,    32,    24,    16,     8,     0
  90 };
  91
  92
  93 /* A quick'n'dirty lookup table to decode an aLaw-encoded byte sample into a
  94  * signed 16-bit sample */
  95 const ALshort aLawDecompressionTable[256] = {
  96      -5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736,
  97      -7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784,
  98      -2752, -2624, -3008, -2880, -2240, -2112, -2496, -2368,
  99      -3776, -3648, -4032, -3904, -3264, -3136, -3520, -3392,
 100     -22016,-20992,-24064,-23040,-17920,-16896,-19968,-18944,
 101     -30208,-29184,-32256,-31232,-26112,-25088,-28160,-27136,
 102     -11008,-10496,-12032,-11520, -8960, -8448, -9984, -9472,
 103     -15104,-14592,-16128,-15616,-13056,-12544,-14080,-13568,
 104       -344,  -328,  -376,  -360,  -280,  -264,  -312,  -296,
 105       -472,  -456,  -504,  -488,  -408,  -392,  -440,  -424,
 106        -88,   -72,  -120,  -104,   -24,    -8,   -56,   -40,
 107       -216,  -200,  -248,  -232,  -152,  -136,  -184,  -168,
 108      -1376, -1312, -1504, -1440, -1120, -1056, -1248, -1184,
 109      -1888, -1824, -2016, -1952, -1632, -1568, -1760, -1696,
 110       -688,  -656,  -752,  -720,  -560,  -528,  -624,  -592,
 111       -944,  -912, -1008,  -976,  -816,  -784,  -880,  -848,
 112       5504,  5248,  6016,  5760,  4480,  4224,  4992,  4736,
 113       7552,  7296,  8064,  7808,  6528,  6272,  7040,  6784,
 114       2752,  2624,  3008,  2880,  2240,  2112,  2496,  2368,
 115       3776,  3648,  4032,  3904,  3264,  3136,  3520,  3392,
 116      22016, 20992, 24064, 23040, 17920, 16896, 19968, 18944,
 117      30208, 29184, 32256, 31232, 26112, 25088, 28160, 27136,
 118      11008, 10496, 12032, 11520,  8960,  8448,  9984,  9472,
 119      15104, 14592, 16128, 15616, 13056, 12544, 14080, 13568,
 120        344,   328,   376,   360,   280,   264,   312,   296,
 121        472,   456,   504,   488,   408,   392,   440,   424,
 122         88,    72,   120,   104,    24,     8,    56,    40,
 123        216,   200,   248,   232,   152,   136,   184,   168,
 124       1376,  1312,  1504,  1440,  1120,  1056,  1248,  1184,
 125       1888,  1824,  2016,  1952,  1632,  1568,  1760,  1696,
 126        688,   656,   752,   720,   560,   528,   624,   592,
 127        944,   912,  1008,   976,   816,   784,   880,   848
 128 };
 129
 130
 131 static void DecodeIMA4Block(ALshort *dst, const ALubyte *src, ALint numchans, ALsizei align)
 132 {
 133     ALint sample[MAX_INPUT_CHANNELS] = { 0 };
 134     ALint index[MAX_INPUT_CHANNELS] = { 0 };
 135     ALuint code[MAX_INPUT_CHANNELS] = { 0 };
 136     ALsizei c, i;
 137
 138     for(c = 0;c < numchans;c++)
 139     {
 140         sample[c]  = *(src++);
 141         sample[c] |= *(src++) << 8;
 142         sample[c]  = (sample[c]^0x8000) - 32768;
 143         index[c]  = *(src++);
 144         index[c] |= *(src++) << 8;
 145         index[c]  = (index[c]^0x8000) - 32768;
 146
 147         index[c] = clampi(index[c], 0, 88);
 148
 149         dst[c] = sample[c];
 150     }
 151
 152     for(i = 1;i < align;i++)
 153     {
 154         if((i&7) == 1)
 155         {
 156             for(c = 0;c < numchans;c++)
 157             {
 158                 code[c]  = *(src++);
 159                 code[c] |= *(src++) << 8;
 160                 code[c] |= *(src++) << 16;
 161                 code[c] |= *(src++) << 24;
 162             }
 163         }
 164
 165         for(c = 0;c < numchans;c++)
 166         {
 167             int nibble = code[c]&0xf;
 168             code[c] >>= 4;
 169
 170             sample[c] += IMA4Codeword[nibble] * IMAStep_size[index[c]] / 8;
 171             sample[c] = clampi(sample[c], -32768, 32767);
 172
 173             index[c] += IMA4Index_adjust[nibble];
 174             index[c] = clampi(index[c], 0, 88);
 175
 176             *(dst++) = sample[c];
 177         }
 178     }
 179 }
 180
 181 static void DecodeMSADPCMBlock(ALshort *dst, const ALubyte *src, ALint numchans, ALsizei align)
 182 {
 183     ALubyte blockpred[MAX_INPUT_CHANNELS] = { 0 };
 184     ALint delta[MAX_INPUT_CHANNELS] = { 0 };
 185     ALshort samples[MAX_INPUT_CHANNELS][2] = { { 0, 0 } };
 186     ALint c, i;
 187
 188     for(c = 0;c < numchans;c++)
 189     {
 190         blockpred[c] = *(src++);
 191         blockpred[c] = minu(blockpred[c], 6);
 192     }
 193     for(c = 0;c < numchans;c++)
 194     {
 195         delta[c]  = *(src++);
 196         delta[c] |= *(src++) << 8;
 197         delta[c]  = (delta[c]^0x8000) - 32768;
 198     }
 199     for(c = 0;c < numchans;c++)
 200     {
 201         samples[c][0]  = *(src++);
 202         samples[c][0] |= *(src++) << 8;
 203         samples[c][0]  = (samples[c][0]^0x8000) - 32768;
 204     }
 205     for(c = 0;c < numchans;c++)
 206     {
 207         samples[c][1]  = *(src++);
 208         samples[c][1] |= *(src++) << 8;
 209         samples[c][1]  = (samples[c][1]^0x8000) - 0x8000;
 210     }
 211
 212     /* Second sample is written first. */
 213     for(c = 0;c < numchans;c++)
 214         *(dst++) = samples[c][1];
 215     for(c = 0;c < numchans;c++)
 216         *(dst++) = samples[c][0];
 217
 218     for(i = 2;i < align;i++)
 219     {
 220         for(c = 0;c < numchans;c++)
 221         {
 222             const ALint num = (i*numchans) + c;
 223             ALint nibble, pred;
 224
 225             /* Read the nibble (first is in the upper bits). */
 226             if(!(num&1))
 227                 nibble = (*src>>4)&0x0f;
 228             else
 229                 nibble = (*(src++))&0x0f;
 230
 231             pred  = (samples[c][0]*MSADPCMAdaptionCoeff[blockpred[c]][0] +
 232                      samples[c][1]*MSADPCMAdaptionCoeff[blockpred[c]][1]) / 256;
 233             pred += ((nibble^0x08) - 0x08) * delta[c];
 234             pred  = clampi(pred, -32768, 32767);
 235
 236             samples[c][1] = samples[c][0];
 237             samples[c][0] = pred;
 238
 239             delta[c] = (MSADPCMAdaption[nibble] * delta[c]) / 256;
 240             delta[c] = maxi(16, delta[c]);
 241
 242             *(dst++) = pred;
 243         }
 244     }
 245 }
 246
 247
 248 void Convert_ALshort_ALima4(ALshort *dst, const ALubyte *src, ALsizei numchans, ALsizei len,
 249                             ALsizei align)
 250 {
 251     ALsizei byte_align = ((align-1)/2 + 4) * numchans;
 252     ALsizei i;
 253
 254     assert(align > 0 && (len%align) == 0);
 255     for(i = 0;i < len;i += align)
 256     {
 257         DecodeIMA4Block(dst, src, numchans, align);
 258         src += byte_align;
 259         dst += align*numchans;
 260     }
 261 }
 262
 263 void Convert_ALshort_ALmsadpcm(ALshort *dst, const ALubyte *src, ALsizei numchans, ALsizei len,
 264                                ALsizei align)
 265 {
 266     ALsizei byte_align = ((align-2)/2 + 7) * numchans;
 267     ALsizei i;
 268
 269     assert(align > 1 && (len%align) == 0);
 270     for(i = 0;i < len;i += align)
 271     {
 272         DecodeMSADPCMBlock(dst, src, numchans, align);
 273         src += byte_align;
 274         dst += align*numchans;
 275     }
 276 }