OpenAL32/sample_cvt.c

   1
   2 #include "config.h"
   3
   4 #include "sample_cvt.h"
   5
   6 #ifdef HAVE_ALLOCA_H
   7 #include <alloca.h>
   8 #endif
   9 #ifdef HAVE_MALLOC_H
  10 #include <malloc.h>
  11 #endif
  12
  13 #include "AL/al.h"
  14 #include "alu.h"
  15 #include "alBuffer.h"
  16
  17
  18 /* IMA ADPCM Stepsize table */
  19 static const int IMAStep_size[89] = {
  20        7,    8,    9,   10,   11,   12,   13,   14,   16,   17,   19,
  21       21,   23,   25,   28,   31,   34,   37,   41,   45,   50,   55,
  22       60,   66,   73,   80,   88,   97,  107,  118,  130,  143,  157,
  23      173,  190,  209,  230,  253,  279,  307,  337,  371,  408,  449,
  24      494,  544,  598,  658,  724,  796,  876,  963, 1060, 1166, 1282,
  25     1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327, 3660,
  26     4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493,10442,
  27    11487,12635,13899,15289,16818,18500,20350,22358,24633,27086,29794,
  28    32767
  29 };
  30
  31 /* IMA4 ADPCM Codeword decode table */
  32 static const int IMA4Codeword[16] = {
  33     1, 3, 5, 7, 9, 11, 13, 15,
  34    -1,-3,-5,-7,-9,-11,-13,-15,
  35 };
  36
  37 /* IMA4 ADPCM Step index adjust decode table */
  38 static const int IMA4Index_adjust[16] = {
  39    -1,-1,-1,-1, 2, 4, 6, 8,
  40    -1,-1,-1,-1, 2, 4, 6, 8
  41 };
  42
  43
  44 /* MSADPCM Adaption table */
  45 static const int MSADPCMAdaption[16] = {
  46     230, 230, 230, 230, 307, 409, 512, 614,
  47     768, 614, 512, 409, 307, 230, 230, 230
  48 };
  49
  50 /* MSADPCM Adaption Coefficient tables */
  51 static const int MSADPCMAdaptionCoeff[7][2] = {
  52     { 256,    0 },
  53     { 512, -256 },
  54     {   0,    0 },
  55     { 192,   64 },
  56     { 240,    0 },
  57     { 460, -208 },
  58     { 392, -232 }
  59 };
  60
  61
  62 /* A quick'n'dirty lookup table to decode a muLaw-encoded byte sample into a
  63  * signed 16-bit sample */
  64 static const ALshort muLawDecompressionTable[256] = {
  65     -32124,-31100,-30076,-29052,-28028,-27004,-25980,-24956,
  66     -23932,-22908,-21884,-20860,-19836,-18812,-17788,-16764,
  67     -15996,-15484,-14972,-14460,-13948,-13436,-12924,-12412,
  68     -11900,-11388,-10876,-10364, -9852, -9340, -8828, -8316,
  69      -7932, -7676, -7420, -7164, -6908, -6652, -6396, -6140,
  70      -5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092,
  71      -3900, -3772, -3644, -3516, -3388, -3260, -3132, -3004,
  72      -2876, -2748, -2620, -2492, -2364, -2236, -2108, -1980,
  73      -1884, -1820, -1756, -1692, -1628, -1564, -1500, -1436,
  74      -1372, -1308, -1244, -1180, -1116, -1052,  -988,  -924,
  75       -876,  -844,  -812,  -780,  -748,  -716,  -684,  -652,
  76       -620,  -588,  -556,  -524,  -492,  -460,  -428,  -396,
  77       -372,  -356,  -340,  -324,  -308,  -292,  -276,  -260,
  78       -244,  -228,  -212,  -196,  -180,  -164,  -148,  -132,
  79       -120,  -112,  -104,   -96,   -88,   -80,   -72,   -64,
  80        -56,   -48,   -40,   -32,   -24,   -16,    -8,     0,
  81      32124, 31100, 30076, 29052, 28028, 27004, 25980, 24956,
  82      23932, 22908, 21884, 20860, 19836, 18812, 17788, 16764,
  83      15996, 15484, 14972, 14460, 13948, 13436, 12924, 12412,
  84      11900, 11388, 10876, 10364,  9852,  9340,  8828,  8316,
  85       7932,  7676,  7420,  7164,  6908,  6652,  6396,  6140,
  86       5884,  5628,  5372,  5116,  4860,  4604,  4348,  4092,
  87       3900,  3772,  3644,  3516,  3388,  3260,  3132,  3004,
  88       2876,  2748,  2620,  2492,  2364,  2236,  2108,  1980,
  89       1884,  1820,  1756,  1692,  1628,  1564,  1500,  1436,
  90       1372,  1308,  1244,  1180,  1116,  1052,   988,   924,
  91        876,   844,   812,   780,   748,   716,   684,   652,
  92        620,   588,   556,   524,   492,   460,   428,   396,
  93        372,   356,   340,   324,   308,   292,   276,   260,
  94        244,   228,   212,   196,   180,   164,   148,   132,
  95        120,   112,   104,    96,    88,    80,    72,    64,
  96         56,    48,    40,    32,    24,    16,     8,     0
  97 };
  98
  99 /* Values used when encoding a muLaw sample */
 100 static const int muLawBias = 0x84;
 101 static const int muLawClip = 32635;
 102 static const char muLawCompressTable[256] = {
 103      0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,
 104      4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
 105      5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 106      5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 107      6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 108      6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 109      6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 110      6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 111      7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 112      7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 113      7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 114      7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 115      7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 116      7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 117      7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 118      7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
 119 };
 120
 121
 122 /* A quick'n'dirty lookup table to decode an aLaw-encoded byte sample into a
 123  * signed 16-bit sample */
 124 static const ALshort aLawDecompressionTable[256] = {
 125      -5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736,
 126      -7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784,
 127      -2752, -2624, -3008, -2880, -2240, -2112, -2496, -2368,
 128      -3776, -3648, -4032, -3904, -3264, -3136, -3520, -3392,
 129     -22016,-20992,-24064,-23040,-17920,-16896,-19968,-18944,
 130     -30208,-29184,-32256,-31232,-26112,-25088,-28160,-27136,
 131     -11008,-10496,-12032,-11520, -8960, -8448, -9984, -9472,
 132     -15104,-14592,-16128,-15616,-13056,-12544,-14080,-13568,
 133       -344,  -328,  -376,  -360,  -280,  -264,  -312,  -296,
 134       -472,  -456,  -504,  -488,  -408,  -392,  -440,  -424,
 135        -88,   -72,  -120,  -104,   -24,    -8,   -56,   -40,
 136       -216,  -200,  -248,  -232,  -152,  -136,  -184,  -168,
 137      -1376, -1312, -1504, -1440, -1120, -1056, -1248, -1184,
 138      -1888, -1824, -2016, -1952, -1632, -1568, -1760, -1696,
 139       -688,  -656,  -752,  -720,  -560,  -528,  -624,  -592,
 140       -944,  -912, -1008,  -976,  -816,  -784,  -880,  -848,
 141       5504,  5248,  6016,  5760,  4480,  4224,  4992,  4736,
 142       7552,  7296,  8064,  7808,  6528,  6272,  7040,  6784,
 143       2752,  2624,  3008,  2880,  2240,  2112,  2496,  2368,
 144       3776,  3648,  4032,  3904,  3264,  3136,  3520,  3392,
 145      22016, 20992, 24064, 23040, 17920, 16896, 19968, 18944,
 146      30208, 29184, 32256, 31232, 26112, 25088, 28160, 27136,
 147      11008, 10496, 12032, 11520,  8960,  8448,  9984,  9472,
 148      15104, 14592, 16128, 15616, 13056, 12544, 14080, 13568,
 149        344,   328,   376,   360,   280,   264,   312,   296,
 150        472,   456,   504,   488,   408,   392,   440,   424,
 151         88,    72,   120,   104,    24,     8,    56,    40,
 152        216,   200,   248,   232,   152,   136,   184,   168,
 153       1376,  1312,  1504,  1440,  1120,  1056,  1248,  1184,
 154       1888,  1824,  2016,  1952,  1632,  1568,  1760,  1696,
 155        688,   656,   752,   720,   560,   528,   624,   592,
 156        944,   912,  1008,   976,   816,   784,   880,   848
 157 };
 158
 159 /* Values used when encoding an aLaw sample */
 160 static const int aLawClip = 32635;
 161 static const char aLawCompressTable[128] = {
 162     1,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,
 163     5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 164     6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 165     6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 166     7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 167     7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 168     7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 169     7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
 170 };
 171
 172
 173 typedef ALubyte ALmulaw;
 174 typedef ALubyte ALalaw;
 175 typedef ALubyte ALima4;
 176 typedef ALubyte ALmsadpcm;
 177 typedef struct {
 178     ALbyte b[3];
 179 } ALbyte3;
 180 extern ALbyte ALbyte3_size_is_not_3[(sizeof(ALbyte3)==sizeof(ALbyte[3]))?1:-1];
 181 typedef struct {
 182     ALubyte b[3];
 183 } ALubyte3;
 184 extern ALbyte ALubyte3_size_is_not_3[(sizeof(ALubyte3)==sizeof(ALubyte[3]))?1:-1];
 185
 186 static inline ALshort DecodeMuLaw(ALmulaw val)
 187 { return muLawDecompressionTable[val]; }
 188
 189 static ALmulaw EncodeMuLaw(ALshort val)
 190 {
 191     ALint mant, exp, sign;
 192
 193     sign = (val>>8) & 0x80;
 194     if(sign)
 195     {
 196         /* -32768 doesn't properly negate on a short; it results in itself.
 197          * So clamp to -32767 */
 198         val = maxi(val, -32767);
 199         val = -val;
 200     }
 201
 202     val = mini(val, muLawClip);
 203     val += muLawBias;
 204
 205     exp = muLawCompressTable[(val>>7) & 0xff];
 206     mant = (val >> (exp+3)) & 0x0f;
 207
 208     return ~(sign | (exp<<4) | mant);
 209 }
 210
 211 static inline ALshort DecodeALaw(ALalaw val)
 212 { return aLawDecompressionTable[val]; }
 213
 214 static ALalaw EncodeALaw(ALshort val)
 215 {
 216     ALint mant, exp, sign;
 217
 218     sign = ((~val) >> 8) & 0x80;
 219     if(!sign)
 220     {
 221         val = maxi(val, -32767);
 222         val = -val;
 223     }
 224     val = mini(val, aLawClip);
 225
 226     if(val >= 256)
 227     {
 228         exp = aLawCompressTable[(val>>8) & 0x7f];
 229         mant = (val >> (exp+3)) & 0x0f;
 230     }
 231     else
 232     {
 233         exp = 0;
 234         mant = val >> 4;
 235     }
 236
 237     return ((exp<<4) | mant) ^ (sign^0x55);
 238 }
 239
 240 static void DecodeIMA4Block(ALshort *dst, const ALima4 *src, ALint numchans, ALsizei align)
 241 {
 242     ALint sample[MAX_INPUT_CHANNELS], index[MAX_INPUT_CHANNELS];
 243     ALuint code[MAX_INPUT_CHANNELS];
 244     ALsizei j,k,c;
 245
 246     for(c = 0;c < numchans;c++)
 247     {
 248         sample[c]  = *(src++);
 249         sample[c] |= *(src++) << 8;
 250         sample[c]  = (sample[c]^0x8000) - 32768;
 251         index[c]  = *(src++);
 252         index[c] |= *(src++) << 8;
 253         index[c]  = (index[c]^0x8000) - 32768;
 254
 255         index[c] = clampi(index[c], 0, 88);
 256
 257         dst[c] = sample[c];
 258     }
 259
 260     for(j = 1;j < align;j += 8)
 261     {
 262         for(c = 0;c < numchans;c++)
 263         {
 264             code[c]  = *(src++);
 265             code[c] |= *(src++) << 8;
 266             code[c] |= *(src++) << 16;
 267             code[c] |= *(src++) << 24;
 268         }
 269
 270         for(k = 0;k < 8;k++)
 271         {
 272             for(c = 0;c < numchans;c++)
 273             {
 274                 int nibble = code[c]&0xf;
 275                 code[c] >>= 4;
 276
 277                 sample[c] += IMA4Codeword[nibble] * IMAStep_size[index[c]] / 8;
 278                 sample[c] = clampi(sample[c], -32768, 32767);
 279
 280                 index[c] += IMA4Index_adjust[nibble];
 281                 index[c] = clampi(index[c], 0, 88);
 282
 283                 dst[(j+k)*numchans + c] = sample[c];
 284             }
 285         }
 286     }
 287 }
 288
 289 static void EncodeIMA4Block(ALima4 *dst, const ALshort *src, ALint *sample, ALint *index, ALint numchans, ALsizei align)
 290 {
 291     ALsizei j,k,c;
 292
 293     for(c = 0;c < numchans;c++)
 294     {
 295         int diff = src[c] - sample[c];
 296         int step = IMAStep_size[index[c]];
 297         int nibble;
 298
 299         nibble = 0;
 300         if(diff < 0)
 301         {
 302             nibble = 0x8;
 303             diff = -diff;
 304         }
 305
 306         diff = mini(step*2, diff);
 307         nibble |= (diff*8/step - 1) / 2;
 308
 309         sample[c] += IMA4Codeword[nibble] * step / 8;
 310         sample[c] = clampi(sample[c], -32768, 32767);
 311
 312         index[c] += IMA4Index_adjust[nibble];
 313         index[c] = clampi(index[c], 0, 88);
 314
 315         *(dst++) = sample[c] & 0xff;
 316         *(dst++) = (sample[c]>>8) & 0xff;
 317         *(dst++) = index[c] & 0xff;
 318         *(dst++) = (index[c]>>8) & 0xff;
 319     }
 320
 321     for(j = 1;j < align;j += 8)
 322     {
 323         for(c = 0;c < numchans;c++)
 324         {
 325             for(k = 0;k < 8;k++)
 326             {
 327                 int diff = src[(j+k)*numchans + c] - sample[c];
 328                 int step = IMAStep_size[index[c]];
 329                 int nibble;
 330
 331                 nibble = 0;
 332                 if(diff < 0)
 333                 {
 334                     nibble = 0x8;
 335                     diff = -diff;
 336                 }
 337
 338                 diff = mini(step*2, diff);
 339                 nibble |= (diff*8/step - 1) / 2;
 340
 341                 sample[c] += IMA4Codeword[nibble] * step / 8;
 342                 sample[c] = clampi(sample[c], -32768, 32767);
 343
 344                 index[c] += IMA4Index_adjust[nibble];
 345                 index[c] = clampi(index[c], 0, 88);
 346
 347                 if(!(k&1)) *dst = nibble;
 348                 else *(dst++) |= nibble<<4;
 349             }
 350         }
 351     }
 352 }
 353
 354
 355 static void DecodeMSADPCMBlock(ALshort *dst, const ALmsadpcm *src, ALint numchans, ALsizei align)
 356 {
 357     ALubyte blockpred[MAX_INPUT_CHANNELS];
 358     ALint delta[MAX_INPUT_CHANNELS];
 359     ALshort samples[MAX_INPUT_CHANNELS][2];
 360     ALint i, j;
 361
 362     for(i = 0;i < numchans;i++)
 363     {
 364         blockpred[i] = *(src++);
 365         blockpred[i] = minu(blockpred[i], 6);
 366     }
 367     for(i = 0;i < numchans;i++)
 368     {
 369         delta[i]  = *(src++);
 370         delta[i] |= *(src++) << 8;
 371         delta[i]  = (delta[i]^0x8000) - 0x8000;
 372     }
 373     for(i = 0;i < numchans;i++)
 374     {
 375         samples[i][0]  = *(src++);
 376         samples[i][0] |= *(src++) << 8;
 377         samples[i][0]  = (samples[i][0]^0x8000) - 0x8000;
 378     }
 379     for(i = 0;i < numchans;i++)
 380     {
 381         samples[i][1]  = *(src++);
 382         samples[i][1] |= *(src++) << 8;
 383         samples[i][1]  = (samples[i][1]^0x8000) - 0x8000;
 384     }
 385
 386     /* Second sample is written first. */
 387     for(i = 0;i < numchans;i++)
 388         *(dst++) = samples[i][1];
 389     for(i = 0;i < numchans;i++)
 390         *(dst++) = samples[i][0];
 391
 392     for(j = 2;j < align;j++)
 393     {
 394         for(i = 0;i < numchans;i++)
 395         {
 396             const ALint num = (j*numchans) + i;
 397             ALint nibble, pred;
 398
 399             /* Read the nibble (first is in the upper bits). */
 400             if(!(num&1))
 401                 nibble = (*src>>4)&0x0f;
 402             else
 403                 nibble = (*(src++))&0x0f;
 404
 405             pred  = (samples[i][0]*MSADPCMAdaptionCoeff[blockpred[i]][0] +
 406                      samples[i][1]*MSADPCMAdaptionCoeff[blockpred[i]][1]) / 256;
 407             pred += ((nibble^0x08) - 0x08) * delta[i];
 408             pred  = clampi(pred, -32768, 32767);
 409
 410             samples[i][1] = samples[i][0];
 411             samples[i][0] = pred;
 412
 413             delta[i] = (MSADPCMAdaption[nibble] * delta[i]) / 256;
 414             delta[i] = maxi(16, delta[i]);
 415
 416             *(dst++) = pred;
 417         }
 418     }
 419 }
 420
 421 /* NOTE: This encoder is pretty dumb/simplistic. Some kind of pre-processing
 422  * that tries to find the optimal block predictors would be nice, at least. A
 423  * multi-pass method that can generate better deltas would be good, too. */
 424 static void EncodeMSADPCMBlock(ALmsadpcm *dst, const ALshort *src, ALint *sample, ALint numchans, ALsizei align)
 425 {
 426     ALubyte blockpred[MAX_INPUT_CHANNELS];
 427     ALint delta[MAX_INPUT_CHANNELS];
 428     ALshort samples[MAX_INPUT_CHANNELS][2];
 429     ALint i, j;
 430
 431     /* Block predictor */
 432     for(i = 0;i < numchans;i++)
 433     {
 434         /* FIXME: Calculate something better. */
 435         blockpred[i] = 0;
 436         *(dst++) = blockpred[i];
 437     }
 438     /* Initial delta */
 439     for(i = 0;i < numchans;i++)
 440     {
 441         delta[i] = 16;
 442         *(dst++) = (delta[i]   ) & 0xff;
 443         *(dst++) = (delta[i]>>8) & 0xff;
 444     }
 445     /* Initial sample 1 */
 446     for(i = 0;i < numchans;i++)
 447     {
 448         samples[i][0] = src[1*numchans + i];
 449         *(dst++) = (samples[i][0]   ) & 0xff;
 450         *(dst++) = (samples[i][0]>>8) & 0xff;
 451     }
 452     /* Initial sample 2 */
 453     for(i = 0;i < numchans;i++)
 454     {
 455         samples[i][1] = src[i];
 456         *(dst++) = (samples[i][1]   ) & 0xff;
 457         *(dst++) = (samples[i][1]>>8) & 0xff;
 458     }
 459
 460     for(j = 2;j < align;j++)
 461     {
 462         for(i = 0;i < numchans;i++)
 463         {
 464             const ALint num = (j*numchans) + i;
 465             ALint nibble = 0;
 466             ALint bias;
 467
 468             sample[i] = (samples[i][0]*MSADPCMAdaptionCoeff[blockpred[i]][0] +
 469                          samples[i][1]*MSADPCMAdaptionCoeff[blockpred[i]][1]) / 256;
 470
 471             nibble = src[num] - sample[i];
 472             if(nibble >= 0)
 473                 bias = delta[i] / 2;
 474             else
 475                 bias = -delta[i] / 2;
 476
 477             nibble = (nibble + bias) / delta[i];
 478             nibble = clampi(nibble, -8, 7)&0x0f;
 479
 480             sample[i] += ((nibble^0x08)-0x08) * delta[i];
 481             sample[i]  = clampi(sample[i], -32768, 32767);
 482
 483             samples[i][1] = samples[i][0];
 484             samples[i][0] = sample[i];
 485
 486             delta[i] = (MSADPCMAdaption[nibble] * delta[i]) / 256;
 487             delta[i] = maxi(16, delta[i]);
 488
 489             if(!(num&1))
 490                 *dst = nibble << 4;
 491             else
 492             {
 493                 *dst |= nibble;
 494                 dst++;
 495             }
 496         }
 497     }
 498 }
 499
 500
 501 static inline ALint DecodeByte3(ALbyte3 val)
 502 {
 503     if(IS_LITTLE_ENDIAN)
 504         return (val.b[2]<<16) | (((ALubyte)val.b[1])<<8) | ((ALubyte)val.b[0]);
 505     return (val.b[0]<<16) | (((ALubyte)val.b[1])<<8) | ((ALubyte)val.b[2]);
 506 }
 507
 508 static inline ALbyte3 EncodeByte3(ALint val)
 509 {
 510     if(IS_LITTLE_ENDIAN)
 511     {
 512         ALbyte3 ret = {{ val, val>>8, val>>16 }};
 513         return ret;
 514     }
 515     else
 516     {
 517         ALbyte3 ret = {{ val>>16, val>>8, val }};
 518         return ret;
 519     }
 520 }
 521
 522 static inline ALint DecodeUByte3(ALubyte3 val)
 523 {
 524     if(IS_LITTLE_ENDIAN)
 525         return (val.b[2]<<16) | (val.b[1]<<8) | (val.b[0]);
 526     return (val.b[0]<<16) | (val.b[1]<<8) | val.b[2];
 527 }
 528
 529 static inline ALubyte3 EncodeUByte3(ALint val)
 530 {
 531     if(IS_LITTLE_ENDIAN)
 532     {
 533         ALubyte3 ret = {{ val, val>>8, val>>16 }};
 534         return ret;
 535     }
 536     else
 537     {
 538         ALubyte3 ret = {{ val>>16, val>>8, val }};
 539         return ret;
 540     }
 541 }
 542
 543
 544 static inline ALbyte Conv_ALbyte_ALbyte(ALbyte val)
 545 { return val; }
 546 static inline ALbyte Conv_ALbyte_ALubyte(ALubyte val)
 547 { return val-128; }
 548 static inline ALbyte Conv_ALbyte_ALshort(ALshort val)
 549 { return val>>8; }
 550 static inline ALbyte Conv_ALbyte_ALushort(ALushort val)
 551 { return (val>>8)-128; }
 552 static inline ALbyte Conv_ALbyte_ALint(ALint val)
 553 { return val>>24; }
 554 static inline ALbyte Conv_ALbyte_ALuint(ALuint val)
 555 { return (val>>24)-128; }
 556 static inline ALbyte Conv_ALbyte_ALfloat(ALfloat val)
 557 {
 558     if(val > 1.0f) return 127;
 559     if(val < -1.0f) return -128;
 560     return (ALint)(val * 127.0f);
 561 }
 562 static inline ALbyte Conv_ALbyte_ALdouble(ALdouble val)
 563 {
 564     if(val > 1.0) return 127;
 565     if(val < -1.0) return -128;
 566     return (ALint)(val * 127.0);
 567 }
 568 static inline ALbyte Conv_ALbyte_ALmulaw(ALmulaw val)
 569 { return Conv_ALbyte_ALshort(DecodeMuLaw(val)); }
 570 static inline ALbyte Conv_ALbyte_ALalaw(ALalaw val)
 571 { return Conv_ALbyte_ALshort(DecodeALaw(val)); }
 572 static inline ALbyte Conv_ALbyte_ALbyte3(ALbyte3 val)
 573 { return DecodeByte3(val)>>16; }
 574 static inline ALbyte Conv_ALbyte_ALubyte3(ALubyte3 val)
 575 { return (DecodeUByte3(val)>>16)-128; }
 576
 577 static inline ALubyte Conv_ALubyte_ALbyte(ALbyte val)
 578 { return val+128; }
 579 static inline ALubyte Conv_ALubyte_ALubyte(ALubyte val)
 580 { return val; }
 581 static inline ALubyte Conv_ALubyte_ALshort(ALshort val)
 582 { return (val>>8)+128; }
 583 static inline ALubyte Conv_ALubyte_ALushort(ALushort val)
 584 { return val>>8; }
 585 static inline ALubyte Conv_ALubyte_ALint(ALint val)
 586 { return (val>>24)+128; }
 587 static inline ALubyte Conv_ALubyte_ALuint(ALuint val)
 588 { return val>>24; }
 589 static inline ALubyte Conv_ALubyte_ALfloat(ALfloat val)
 590 {
 591     if(val > 1.0f) return 255;
 592     if(val < -1.0f) return 0;
 593     return (ALint)(val * 127.0f) + 128;
 594 }
 595 static inline ALubyte Conv_ALubyte_ALdouble(ALdouble val)
 596 {
 597     if(val > 1.0) return 255;
 598     if(val < -1.0) return 0;
 599     return (ALint)(val * 127.0) + 128;
 600 }
 601 static inline ALubyte Conv_ALubyte_ALmulaw(ALmulaw val)
 602 { return Conv_ALubyte_ALshort(DecodeMuLaw(val)); }
 603 static inline ALubyte Conv_ALubyte_ALalaw(ALalaw val)
 604 { return Conv_ALubyte_ALshort(DecodeALaw(val)); }
 605 static inline ALubyte Conv_ALubyte_ALbyte3(ALbyte3 val)
 606 { return (DecodeByte3(val)>>16)+128; }
 607 static inline ALubyte Conv_ALubyte_ALubyte3(ALubyte3 val)
 608 { return DecodeUByte3(val)>>16; }
 609
 610 static inline ALshort Conv_ALshort_ALbyte(ALbyte val)
 611 { return val<<8; }
 612 static inline ALshort Conv_ALshort_ALubyte(ALubyte val)
 613 { return (val-128)<<8; }
 614 static inline ALshort Conv_ALshort_ALshort(ALshort val)
 615 { return val; }
 616 static inline ALshort Conv_ALshort_ALushort(ALushort val)
 617 { return val-32768; }
 618 static inline ALshort Conv_ALshort_ALint(ALint val)
 619 { return val>>16; }
 620 static inline ALshort Conv_ALshort_ALuint(ALuint val)
 621 { return (val>>16)-32768; }
 622 static inline ALshort Conv_ALshort_ALfloat(ALfloat val)
 623 {
 624     if(val > 1.0f) return 32767;
 625     if(val < -1.0f) return -32768;
 626     return (ALint)(val * 32767.0f);
 627 }
 628 static inline ALshort Conv_ALshort_ALdouble(ALdouble val)
 629 {
 630     if(val > 1.0) return 32767;
 631     if(val < -1.0) return -32768;
 632     return (ALint)(val * 32767.0);
 633 }
 634 static inline ALshort Conv_ALshort_ALmulaw(ALmulaw val)
 635 { return Conv_ALshort_ALshort(DecodeMuLaw(val)); }
 636 static inline ALshort Conv_ALshort_ALalaw(ALalaw val)
 637 { return Conv_ALshort_ALshort(DecodeALaw(val)); }
 638 static inline ALshort Conv_ALshort_ALbyte3(ALbyte3 val)
 639 { return DecodeByte3(val)>>8; }
 640 static inline ALshort Conv_ALshort_ALubyte3(ALubyte3 val)
 641 { return (DecodeUByte3(val)>>8)-32768; }
 642
 643 static inline ALushort Conv_ALushort_ALbyte(ALbyte val)
 644 { return (val+128)<<8; }
 645 static inline ALushort Conv_ALushort_ALubyte(ALubyte val)
 646 { return val<<8; }
 647 static inline ALushort Conv_ALushort_ALshort(ALshort val)
 648 { return val+32768; }
 649 static inline ALushort Conv_ALushort_ALushort(ALushort val)
 650 { return val; }
 651 static inline ALushort Conv_ALushort_ALint(ALint val)
 652 { return (val>>16)+32768; }
 653 static inline ALushort Conv_ALushort_ALuint(ALuint val)
 654 { return val>>16; }
 655 static inline ALushort Conv_ALushort_ALfloat(ALfloat val)
 656 {
 657     if(val > 1.0f) return 65535;
 658     if(val < -1.0f) return 0;
 659     return (ALint)(val * 32767.0f) + 32768;
 660 }
 661 static inline ALushort Conv_ALushort_ALdouble(ALdouble val)
 662 {
 663     if(val > 1.0) return 65535;
 664     if(val < -1.0) return 0;
 665     return (ALint)(val * 32767.0) + 32768;
 666 }
 667 static inline ALushort Conv_ALushort_ALmulaw(ALmulaw val)
 668 { return Conv_ALushort_ALshort(DecodeMuLaw(val)); }
 669 static inline ALushort Conv_ALushort_ALalaw(ALalaw val)
 670 { return Conv_ALushort_ALshort(DecodeALaw(val)); }
 671 static inline ALushort Conv_ALushort_ALbyte3(ALbyte3 val)
 672 { return (DecodeByte3(val)>>8)+32768; }
 673 static inline ALushort Conv_ALushort_ALubyte3(ALubyte3 val)
 674 { return DecodeUByte3(val)>>8; }
 675
 676 static inline ALint Conv_ALint_ALbyte(ALbyte val)
 677 { return val<<24; }
 678 static inline ALint Conv_ALint_ALubyte(ALubyte val)
 679 { return (val-128)<<24; }
 680 static inline ALint Conv_ALint_ALshort(ALshort val)
 681 { return val<<16; }
 682 static inline ALint Conv_ALint_ALushort(ALushort val)
 683 { return (val-32768)<<16; }
 684 static inline ALint Conv_ALint_ALint(ALint val)
 685 { return val; }
 686 static inline ALint Conv_ALint_ALuint(ALuint val)
 687 { return val-2147483648u; }
 688 static inline ALint Conv_ALint_ALfloat(ALfloat val)
 689 {
 690     if(val > 1.0f) return 2147483647;
 691     if(val < -1.0f) return -2147483647-1;
 692     return (ALint)(val*16777215.0f) << 7;
 693 }
 694 static inline ALint Conv_ALint_ALdouble(ALdouble val)
 695 {
 696     if(val > 1.0) return 2147483647;
 697     if(val < -1.0) return -2147483647-1;
 698     return (ALint)(val * 2147483647.0);
 699 }
 700 static inline ALint Conv_ALint_ALmulaw(ALmulaw val)
 701 { return Conv_ALint_ALshort(DecodeMuLaw(val)); }
 702 static inline ALint Conv_ALint_ALalaw(ALalaw val)
 703 { return Conv_ALint_ALshort(DecodeALaw(val)); }
 704 static inline ALint Conv_ALint_ALbyte3(ALbyte3 val)
 705 { return DecodeByte3(val)<<8; }
 706 static inline ALint Conv_ALint_ALubyte3(ALubyte3 val)
 707 { return (DecodeUByte3(val)-8388608)<<8; }
 708
 709 static inline ALuint Conv_ALuint_ALbyte(ALbyte val)
 710 { return (val+128)<<24; }
 711 static inline ALuint Conv_ALuint_ALubyte(ALubyte val)
 712 { return val<<24; }
 713 static inline ALuint Conv_ALuint_ALshort(ALshort val)
 714 { return (val+32768)<<16; }
 715 static inline ALuint Conv_ALuint_ALushort(ALushort val)
 716 { return val<<16; }
 717 static inline ALuint Conv_ALuint_ALint(ALint val)
 718 { return val+2147483648u; }
 719 static inline ALuint Conv_ALuint_ALuint(ALuint val)
 720 { return val; }
 721 static inline ALuint Conv_ALuint_ALfloat(ALfloat val)
 722 {
 723     if(val > 1.0f) return 4294967295u;
 724     if(val < -1.0f) return 0;
 725     return ((ALint)(val*16777215.0f)<<7) + 2147483648u;
 726 }
 727 static inline ALuint Conv_ALuint_ALdouble(ALdouble val)
 728 {
 729     if(val > 1.0) return 4294967295u;
 730     if(val < -1.0) return 0;
 731     return (ALint)(val * 2147483647.0) + 2147483648u;
 732 }
 733 static inline ALuint Conv_ALuint_ALmulaw(ALmulaw val)
 734 { return Conv_ALuint_ALshort(DecodeMuLaw(val)); }
 735 static inline ALuint Conv_ALuint_ALalaw(ALalaw val)
 736 { return Conv_ALuint_ALshort(DecodeALaw(val)); }
 737 static inline ALuint Conv_ALuint_ALbyte3(ALbyte3 val)
 738 { return (DecodeByte3(val)+8388608)<<8; }
 739 static inline ALuint Conv_ALuint_ALubyte3(ALubyte3 val)
 740 { return DecodeUByte3(val)<<8; }
 741
 742 static inline ALfloat Conv_ALfloat_ALbyte(ALbyte val)
 743 { return val * (1.0f/127.0f); }
 744 static inline ALfloat Conv_ALfloat_ALubyte(ALubyte val)
 745 { return (val-128) * (1.0f/127.0f); }
 746 static inline ALfloat Conv_ALfloat_ALshort(ALshort val)
 747 { return val * (1.0f/32767.0f); }
 748 static inline ALfloat Conv_ALfloat_ALushort(ALushort val)
 749 { return (val-32768) * (1.0f/32767.0f); }
 750 static inline ALfloat Conv_ALfloat_ALint(ALint val)
 751 { return (ALfloat)(val>>7) * (1.0f/16777215.0f); }
 752 static inline ALfloat Conv_ALfloat_ALuint(ALuint val)
 753 { return (ALfloat)((ALint)(val>>7)-16777216) * (1.0f/16777215.0f); }
 754 static inline ALfloat Conv_ALfloat_ALfloat(ALfloat val)
 755 { return (val==val) ? val : 0.0f; }
 756 static inline ALfloat Conv_ALfloat_ALdouble(ALdouble val)
 757 { return (val==val) ? (ALfloat)val : 0.0f; }
 758 static inline ALfloat Conv_ALfloat_ALmulaw(ALmulaw val)
 759 { return Conv_ALfloat_ALshort(DecodeMuLaw(val)); }
 760 static inline ALfloat Conv_ALfloat_ALalaw(ALalaw val)
 761 { return Conv_ALfloat_ALshort(DecodeALaw(val)); }
 762 static inline ALfloat Conv_ALfloat_ALbyte3(ALbyte3 val)
 763 { return (ALfloat)(DecodeByte3(val) * (1.0/8388607.0)); }
 764 static inline ALfloat Conv_ALfloat_ALubyte3(ALubyte3 val)
 765 { return (ALfloat)((DecodeUByte3(val)-8388608) * (1.0/8388607.0)); }
 766
 767 static inline ALdouble Conv_ALdouble_ALbyte(ALbyte val)
 768 { return val * (1.0/127.0); }
 769 static inline ALdouble Conv_ALdouble_ALubyte(ALubyte val)
 770 { return (val-128) * (1.0/127.0); }
 771 static inline ALdouble Conv_ALdouble_ALshort(ALshort val)
 772 { return val * (1.0/32767.0); }
 773 static inline ALdouble Conv_ALdouble_ALushort(ALushort val)
 774 { return (val-32768) * (1.0/32767.0); }
 775 static inline ALdouble Conv_ALdouble_ALint(ALint val)
 776 { return val * (1.0/2147483647.0); }
 777 static inline ALdouble Conv_ALdouble_ALuint(ALuint val)
 778 { return (ALint)(val-2147483648u) * (1.0/2147483647.0); }
 779 static inline ALdouble Conv_ALdouble_ALfloat(ALfloat val)
 780 { return (val==val) ? val : 0.0f; }
 781 static inline ALdouble Conv_ALdouble_ALdouble(ALdouble val)
 782 { return (val==val) ? val : 0.0; }
 783 static inline ALdouble Conv_ALdouble_ALmulaw(ALmulaw val)
 784 { return Conv_ALdouble_ALshort(DecodeMuLaw(val)); }
 785 static inline ALdouble Conv_ALdouble_ALalaw(ALalaw val)
 786 { return Conv_ALdouble_ALshort(DecodeALaw(val)); }
 787 static inline ALdouble Conv_ALdouble_ALbyte3(ALbyte3 val)
 788 { return DecodeByte3(val) * (1.0/8388607.0); }
 789 static inline ALdouble Conv_ALdouble_ALubyte3(ALubyte3 val)
 790 { return (DecodeUByte3(val)-8388608) * (1.0/8388607.0); }
 791
 792 #define DECL_TEMPLATE(T)                                                      \
 793 static inline ALmulaw Conv_ALmulaw_##T(T val)                                 \
 794 { return EncodeMuLaw(Conv_ALshort_##T(val)); }
 795
 796 DECL_TEMPLATE(ALbyte)
 797 DECL_TEMPLATE(ALubyte)
 798 DECL_TEMPLATE(ALshort)
 799 DECL_TEMPLATE(ALushort)
 800 DECL_TEMPLATE(ALint)
 801 DECL_TEMPLATE(ALuint)
 802 DECL_TEMPLATE(ALfloat)
 803 DECL_TEMPLATE(ALdouble)
 804 static inline ALmulaw Conv_ALmulaw_ALmulaw(ALmulaw val)
 805 { return val; }
 806 DECL_TEMPLATE(ALalaw)
 807 DECL_TEMPLATE(ALbyte3)
 808 DECL_TEMPLATE(ALubyte3)
 809
 810 #undef DECL_TEMPLATE
 811
 812 #define DECL_TEMPLATE(T)                                                      \
 813 static inline ALalaw Conv_ALalaw_##T(T val)                                   \
 814 { return EncodeALaw(Conv_ALshort_##T(val)); }
 815
 816 DECL_TEMPLATE(ALbyte)
 817 DECL_TEMPLATE(ALubyte)
 818 DECL_TEMPLATE(ALshort)
 819 DECL_TEMPLATE(ALushort)
 820 DECL_TEMPLATE(ALint)
 821 DECL_TEMPLATE(ALuint)
 822 DECL_TEMPLATE(ALfloat)
 823 DECL_TEMPLATE(ALdouble)
 824 DECL_TEMPLATE(ALmulaw)
 825 static inline ALalaw Conv_ALalaw_ALalaw(ALalaw val)
 826 { return val; }
 827 DECL_TEMPLATE(ALbyte3)
 828 DECL_TEMPLATE(ALubyte3)
 829
 830 #undef DECL_TEMPLATE
 831
 832 #define DECL_TEMPLATE(T)                                                      \
 833 static inline ALbyte3 Conv_ALbyte3_##T(T val)                                 \
 834 { return EncodeByte3(Conv_ALint_##T(val)>>8); }
 835
 836 DECL_TEMPLATE(ALbyte)
 837 DECL_TEMPLATE(ALubyte)
 838 DECL_TEMPLATE(ALshort)
 839 DECL_TEMPLATE(ALushort)
 840 DECL_TEMPLATE(ALint)
 841 DECL_TEMPLATE(ALuint)
 842 DECL_TEMPLATE(ALfloat)
 843 DECL_TEMPLATE(ALdouble)
 844 DECL_TEMPLATE(ALmulaw)
 845 DECL_TEMPLATE(ALalaw)
 846 static inline ALbyte3 Conv_ALbyte3_ALbyte3(ALbyte3 val)
 847 { return val; }
 848 DECL_TEMPLATE(ALubyte3)
 849
 850 #undef DECL_TEMPLATE
 851
 852 #define DECL_TEMPLATE(T)                                                      \
 853 static inline ALubyte3 Conv_ALubyte3_##T(T val)                               \
 854 { return EncodeUByte3(Conv_ALuint_##T(val)>>8); }
 855
 856 DECL_TEMPLATE(ALbyte)
 857 DECL_TEMPLATE(ALubyte)
 858 DECL_TEMPLATE(ALshort)
 859 DECL_TEMPLATE(ALushort)
 860 DECL_TEMPLATE(ALint)
 861 DECL_TEMPLATE(ALuint)
 862 DECL_TEMPLATE(ALfloat)
 863 DECL_TEMPLATE(ALdouble)
 864 DECL_TEMPLATE(ALmulaw)
 865 DECL_TEMPLATE(ALalaw)
 866 DECL_TEMPLATE(ALbyte3)
 867 static inline ALubyte3 Conv_ALubyte3_ALubyte3(ALubyte3 val)
 868 { return val; }
 869
 870 #undef DECL_TEMPLATE
 871
 872
 873 #define DECL_TEMPLATE(T1, T2)                                                 \
 874 static void Convert_##T1##_##T2(T1 *dst, const T2 *src, ALuint numchans,      \
 875                                 ALuint len, ALsizei UNUSED(align))            \
 876 {                                                                             \
 877     ALuint i, j;                                                              \
 878     for(i = 0;i < len;i++)                                                    \
 879     {                                                                         \
 880         for(j = 0;j < numchans;j++)                                           \
 881             *(dst++) = Conv_##T1##_##T2(*(src++));                            \
 882     }                                                                         \
 883 }
 884
 885 #define DECL_TEMPLATE2(T)  \
 886 DECL_TEMPLATE(T, ALbyte)   \
 887 DECL_TEMPLATE(T, ALubyte)  \
 888 DECL_TEMPLATE(T, ALshort)  \
 889 DECL_TEMPLATE(T, ALushort) \
 890 DECL_TEMPLATE(T, ALint)    \
 891 DECL_TEMPLATE(T, ALuint)   \
 892 DECL_TEMPLATE(T, ALfloat)  \
 893 DECL_TEMPLATE(T, ALdouble) \
 894 DECL_TEMPLATE(T, ALmulaw)  \
 895 DECL_TEMPLATE(T, ALalaw)   \
 896 DECL_TEMPLATE(T, ALbyte3)  \
 897 DECL_TEMPLATE(T, ALubyte3)
 898
 899 DECL_TEMPLATE2(ALbyte)
 900 DECL_TEMPLATE2(ALubyte)
 901 DECL_TEMPLATE2(ALshort)
 902 DECL_TEMPLATE2(ALushort)
 903 DECL_TEMPLATE2(ALint)
 904 DECL_TEMPLATE2(ALuint)
 905 DECL_TEMPLATE2(ALfloat)
 906 DECL_TEMPLATE2(ALdouble)
 907 DECL_TEMPLATE2(ALmulaw)
 908 DECL_TEMPLATE2(ALalaw)
 909 DECL_TEMPLATE2(ALbyte3)
 910 DECL_TEMPLATE2(ALubyte3)
 911
 912 #undef DECL_TEMPLATE2
 913 #undef DECL_TEMPLATE
 914
 915 #define DECL_TEMPLATE(T)                                                      \
 916 static void Convert_##T##_ALima4(T *dst, const ALima4 *src, ALuint numchans,  \
 917                                  ALuint len, ALuint align)                    \
 918 {                                                                             \
 919     ALsizei byte_align = ((align-1)/2 + 4) * numchans;                        \
 920     ALuint i, j, k;                                                           \
 921     ALshort *tmp;                                                             \
 922                                                                               \
 923     tmp = alloca(align*numchans*sizeof(*tmp));                                \
 924     for(i = 0;i < len;i += align)                                             \
 925     {                                                                         \
 926         DecodeIMA4Block(tmp, src, numchans, align);                           \
 927         src += byte_align;                                                    \
 928                                                                               \
 929         for(j = 0;j < align;j++)                                              \
 930         {                                                                     \
 931             for(k = 0;k < numchans;k++)                                       \
 932                 *(dst++) = Conv_##T##_ALshort(tmp[j*numchans + k]);           \
 933         }                                                                     \
 934     }                                                                         \
 935 }
 936
 937 DECL_TEMPLATE(ALbyte)
 938 DECL_TEMPLATE(ALubyte)
 939 static void Convert_ALshort_ALima4(ALshort *dst, const ALima4 *src, ALuint numchans,
 940                                    ALuint len, ALuint align)
 941 {
 942     ALsizei byte_align = ((align-1)/2 + 4) * numchans;
 943     ALuint i;
 944
 945     for(i = 0;i < len;i += align)
 946     {
 947         DecodeIMA4Block(dst, src, numchans, align);
 948         src += byte_align;
 949         dst += align*numchans;
 950     }
 951 }
 952 DECL_TEMPLATE(ALushort)
 953 DECL_TEMPLATE(ALint)
 954 DECL_TEMPLATE(ALuint)
 955 DECL_TEMPLATE(ALfloat)
 956 DECL_TEMPLATE(ALdouble)
 957 DECL_TEMPLATE(ALmulaw)
 958 DECL_TEMPLATE(ALalaw)
 959 DECL_TEMPLATE(ALbyte3)
 960 DECL_TEMPLATE(ALubyte3)
 961
 962 #undef DECL_TEMPLATE
 963
 964 #define DECL_TEMPLATE(T)                                                      \
 965 static void Convert_ALima4_##T(ALima4 *dst, const T *src, ALuint numchans,    \
 966                                ALuint len, ALuint align)                      \
 967 {                                                                             \
 968     ALint sample[MAX_INPUT_CHANNELS] = {0,0,0,0,0,0,0,0};                     \
 969     ALint index[MAX_INPUT_CHANNELS] = {0,0,0,0,0,0,0,0};                      \
 970     ALsizei byte_align = ((align-1)/2 + 4) * numchans;                        \
 971     ALuint i, j, k;                                                           \
 972     ALshort *tmp;                                                             \
 973                                                                               \
 974     tmp = alloca(align*numchans*sizeof(*tmp));                                \
 975     for(i = 0;i < len;i += align)                                             \
 976     {                                                                         \
 977         for(j = 0;j < align;j++)                                              \
 978         {                                                                     \
 979             for(k = 0;k < numchans;k++)                                       \
 980                 tmp[j*numchans + k] = Conv_ALshort_##T(*(src++));             \
 981         }                                                                     \
 982         EncodeIMA4Block(dst, tmp, sample, index, numchans, align);            \
 983         dst += byte_align;                                                    \
 984     }                                                                         \
 985 }
 986
 987 DECL_TEMPLATE(ALbyte)
 988 DECL_TEMPLATE(ALubyte)
 989 static void Convert_ALima4_ALshort(ALima4 *dst, const ALshort *src,
 990                                    ALuint numchans, ALuint len, ALuint align)
 991 {
 992     ALint sample[MAX_INPUT_CHANNELS] = {0,0,0,0,0,0,0,0};
 993     ALint index[MAX_INPUT_CHANNELS] = {0,0,0,0,0,0,0,0};
 994     ALsizei byte_align = ((align-1)/2 + 4) * numchans;
 995     ALuint i;
 996
 997     for(i = 0;i < len;i += align)
 998     {
 999         EncodeIMA4Block(dst, src, sample, index, numchans, align);
1000         src += align*numchans;
1001         dst += byte_align;
1002     }
1003 }
1004 DECL_TEMPLATE(ALushort)
1005 DECL_TEMPLATE(ALint)
1006 DECL_TEMPLATE(ALuint)
1007 DECL_TEMPLATE(ALfloat)
1008 DECL_TEMPLATE(ALdouble)
1009 DECL_TEMPLATE(ALmulaw)
1010 DECL_TEMPLATE(ALalaw)
1011 DECL_TEMPLATE(ALbyte3)
1012 DECL_TEMPLATE(ALubyte3)
1013
1014 #undef DECL_TEMPLATE
1015
1016
1017 #define DECL_TEMPLATE(T)                                                      \
1018 static void Convert_##T##_ALmsadpcm(T *dst, const ALmsadpcm *src,             \
1019                                     ALuint numchans, ALuint len,              \
1020                                     ALuint align)                             \
1021 {                                                                             \
1022     ALsizei byte_align = ((align-2)/2 + 7) * numchans;                        \
1023     ALuint i, j, k;                                                           \
1024     ALshort *tmp;                                                             \
1025                                                                               \
1026     tmp = alloca(align*numchans*sizeof(*tmp));                                \
1027     for(i = 0;i < len;i += align)                                             \
1028     {                                                                         \
1029         DecodeMSADPCMBlock(tmp, src, numchans, align);                        \
1030         src += byte_align;                                                    \
1031                                                                               \
1032         for(j = 0;j < align;j++)                                              \
1033         {                                                                     \
1034             for(k = 0;k < numchans;k++)                                       \
1035                 *(dst++) = Conv_##T##_ALshort(tmp[j*numchans + k]);           \
1036         }                                                                     \
1037     }                                                                         \
1038 }
1039
1040 DECL_TEMPLATE(ALbyte)
1041 DECL_TEMPLATE(ALubyte)
1042 static void Convert_ALshort_ALmsadpcm(ALshort *dst, const ALmsadpcm *src,
1043                                       ALuint numchans, ALuint len,
1044                                       ALuint align)
1045 {
1046     ALsizei byte_align = ((align-2)/2 + 7) * numchans;
1047     ALuint i;
1048
1049     for(i = 0;i < len;i += align)
1050     {
1051         DecodeMSADPCMBlock(dst, src, numchans, align);
1052         src += byte_align;
1053         dst += align*numchans;
1054     }
1055 }
1056 DECL_TEMPLATE(ALushort)
1057 DECL_TEMPLATE(ALint)
1058 DECL_TEMPLATE(ALuint)
1059 DECL_TEMPLATE(ALfloat)
1060 DECL_TEMPLATE(ALdouble)
1061 DECL_TEMPLATE(ALmulaw)
1062 DECL_TEMPLATE(ALalaw)
1063 DECL_TEMPLATE(ALbyte3)
1064 DECL_TEMPLATE(ALubyte3)
1065
1066 #undef DECL_TEMPLATE
1067
1068 #define DECL_TEMPLATE(T)                                                      \
1069 static void Convert_ALmsadpcm_##T(ALmsadpcm *dst, const T *src,               \
1070                                   ALuint numchans, ALuint len, ALuint align)  \
1071 {                                                                             \
1072     ALint sample[MaxChannels] = {0,0,0,0,0,0,0,0};                            \
1073     ALsizei byte_align = ((align-2)/2 + 7) * numchans;                        \
1074     ALuint i, j, k;                                                           \
1075     ALshort *tmp;                                                             \
1076                                                                               \
1077     tmp = alloca(align*numchans*sizeof(*tmp));                                \
1078     for(i = 0;i < len;i += align)                                             \
1079     {                                                                         \
1080         for(j = 0;j < align;j++)                                              \
1081         {                                                                     \
1082             for(k = 0;k < numchans;k++)                                       \
1083                 tmp[j*numchans + k] = Conv_ALshort_##T(*(src++));             \
1084         }                                                                     \
1085         EncodeMSADPCMBlock(dst, tmp, sample, numchans, align);                \
1086         dst += byte_align;                                                    \
1087     }                                                                         \
1088 }
1089
1090 DECL_TEMPLATE(ALbyte)
1091 DECL_TEMPLATE(ALubyte)
1092 static void Convert_ALmsadpcm_ALshort(ALmsadpcm *dst, const ALshort *src,
1093                                       ALuint numchans, ALuint len, ALuint align)
1094 {
1095     ALint sample[MaxChannels] = {0,0,0,0,0,0,0,0};
1096     ALsizei byte_align = ((align-2)/2 + 7) * numchans;
1097     ALuint i;
1098
1099     for(i = 0;i < len;i += align)
1100     {
1101         EncodeMSADPCMBlock(dst, src, sample, numchans, align);
1102         src += align*numchans;
1103         dst += byte_align;
1104     }
1105 }
1106 DECL_TEMPLATE(ALushort)
1107 DECL_TEMPLATE(ALint)
1108 DECL_TEMPLATE(ALuint)
1109 DECL_TEMPLATE(ALfloat)
1110 DECL_TEMPLATE(ALdouble)
1111 DECL_TEMPLATE(ALmulaw)
1112 DECL_TEMPLATE(ALalaw)
1113 DECL_TEMPLATE(ALbyte3)
1114 DECL_TEMPLATE(ALubyte3)
1115
1116 #undef DECL_TEMPLATE
1117
1118 /* NOTE: We don't store compressed samples internally, so these conversions
1119  * should never happen. */
1120 static void Convert_ALima4_ALima4(ALima4* UNUSED(dst), const ALima4* UNUSED(src),
1121                                   ALuint UNUSED(numchans), ALuint UNUSED(len),
1122                                   ALuint UNUSED(align))
1123 {
1124     ERR("Unexpected IMA4-to-IMA4 conversion!\n");
1125 }
1126
1127 static void Convert_ALmsadpcm_ALmsadpcm(ALmsadpcm* UNUSED(dst), const ALmsadpcm* UNUSED(src),
1128                                         ALuint UNUSED(numchans), ALuint UNUSED(len),
1129                                         ALuint UNUSED(align))
1130 {
1131     ERR("Unexpected MSADPCM-to-MSADPCM conversion!\n");
1132 }
1133
1134 static void Convert_ALmsadpcm_ALima4(ALmsadpcm* UNUSED(dst), const ALima4* UNUSED(src),
1135                                      ALuint UNUSED(numchans), ALuint UNUSED(len),
1136                                      ALuint UNUSED(align))
1137 {
1138     ERR("Unexpected IMA4-to-MSADPCM conversion!\n");
1139 }
1140
1141 static void Convert_ALima4_ALmsadpcm(ALima4* UNUSED(dst), const ALmsadpcm* UNUSED(src),
1142                                      ALuint UNUSED(numchans), ALuint UNUSED(len),
1143                                      ALuint UNUSED(align))
1144 {
1145     ERR("Unexpected MSADPCM-to-IMA4 conversion!\n");
1146 }
1147
1148
1149 #define DECL_TEMPLATE(T)                                                      \
1150 static void Convert_##T(T *dst, const ALvoid *src, enum UserFmtType srcType,  \
1151                         ALsizei numchans, ALsizei len, ALsizei align)         \
1152 {                                                                             \
1153     switch(srcType)                                                           \
1154     {                                                                         \
1155         case UserFmtByte:                                                     \
1156             Convert_##T##_ALbyte(dst, src, numchans, len, align);             \
1157             break;                                                            \
1158         case UserFmtUByte:                                                    \
1159             Convert_##T##_ALubyte(dst, src, numchans, len, align);            \
1160             break;                                                            \
1161         case UserFmtShort:                                                    \
1162             Convert_##T##_ALshort(dst, src, numchans, len, align);            \
1163             break;                                                            \
1164         case UserFmtUShort:                                                   \
1165             Convert_##T##_ALushort(dst, src, numchans, len, align);           \
1166             break;                                                            \
1167         case UserFmtInt:                                                      \
1168             Convert_##T##_ALint(dst, src, numchans, len, align);              \
1169             break;                                                            \
1170         case UserFmtUInt:                                                     \
1171             Convert_##T##_ALuint(dst, src, numchans, len, align);             \
1172             break;                                                            \
1173         case UserFmtFloat:                                                    \
1174             Convert_##T##_ALfloat(dst, src, numchans, len, align);            \
1175             break;                                                            \
1176         case UserFmtDouble:                                                   \
1177             Convert_##T##_ALdouble(dst, src, numchans, len, align);           \
1178             break;                                                            \
1179         case UserFmtMulaw:                                                    \
1180             Convert_##T##_ALmulaw(dst, src, numchans, len, align);            \
1181             break;                                                            \
1182         case UserFmtAlaw:                                                     \
1183             Convert_##T##_ALalaw(dst, src, numchans, len, align);             \
1184             break;                                                            \
1185         case UserFmtIMA4:                                                     \
1186             Convert_##T##_ALima4(dst, src, numchans, len, align);             \
1187             break;                                                            \
1188         case UserFmtMSADPCM:                                                  \
1189             Convert_##T##_ALmsadpcm(dst, src, numchans, len, align);          \
1190             break;                                                            \
1191         case UserFmtByte3:                                                    \
1192             Convert_##T##_ALbyte3(dst, src, numchans, len, align);            \
1193             break;                                                            \
1194         case UserFmtUByte3:                                                   \
1195             Convert_##T##_ALubyte3(dst, src, numchans, len, align);           \
1196             break;                                                            \
1197     }                                                                         \
1198 }
1199
1200 DECL_TEMPLATE(ALbyte)
1201 DECL_TEMPLATE(ALubyte)
1202 DECL_TEMPLATE(ALshort)
1203 DECL_TEMPLATE(ALushort)
1204 DECL_TEMPLATE(ALint)
1205 DECL_TEMPLATE(ALuint)
1206 DECL_TEMPLATE(ALfloat)
1207 DECL_TEMPLATE(ALdouble)
1208 DECL_TEMPLATE(ALmulaw)
1209 DECL_TEMPLATE(ALalaw)
1210 DECL_TEMPLATE(ALima4)
1211 DECL_TEMPLATE(ALmsadpcm)
1212 DECL_TEMPLATE(ALbyte3)
1213 DECL_TEMPLATE(ALubyte3)
1214
1215 #undef DECL_TEMPLATE
1216
1217
1218 void ConvertData(ALvoid *dst, enum UserFmtType dstType, const ALvoid *src, enum UserFmtType srcType, ALsizei numchans, ALsizei len, ALsizei align)
1219 {
1220     switch(dstType)
1221     {
1222         case UserFmtByte:
1223             Convert_ALbyte(dst, src, srcType, numchans, len, align);
1224             break;
1225         case UserFmtUByte:
1226             Convert_ALubyte(dst, src, srcType, numchans, len, align);
1227             break;
1228         case UserFmtShort:
1229             Convert_ALshort(dst, src, srcType, numchans, len, align);
1230             break;
1231         case UserFmtUShort:
1232             Convert_ALushort(dst, src, srcType, numchans, len, align);
1233             break;
1234         case UserFmtInt:
1235             Convert_ALint(dst, src, srcType, numchans, len, align);
1236             break;
1237         case UserFmtUInt:
1238             Convert_ALuint(dst, src, srcType, numchans, len, align);
1239             break;
1240         case UserFmtFloat:
1241             Convert_ALfloat(dst, src, srcType, numchans, len, align);
1242             break;
1243         case UserFmtDouble:
1244             Convert_ALdouble(dst, src, srcType, numchans, len, align);
1245             break;
1246         case UserFmtMulaw:
1247             Convert_ALmulaw(dst, src, srcType, numchans, len, align);
1248             break;
1249         case UserFmtAlaw:
1250             Convert_ALalaw(dst, src, srcType, numchans, len, align);
1251             break;
1252         case UserFmtIMA4:
1253             Convert_ALima4(dst, src, srcType, numchans, len, align);
1254             break;
1255         case UserFmtMSADPCM:
1256             Convert_ALmsadpcm(dst, src, srcType, numchans, len, align);
1257             break;
1258         case UserFmtByte3:
1259             Convert_ALbyte3(dst, src, srcType, numchans, len, align);
1260             break;
1261         case UserFmtUByte3:
1262             Convert_ALubyte3(dst, src, srcType, numchans, len, align);
1263             break;
1264     }
1265 }