aboutsummaryrefslogtreecommitdiffstats
path: root/OpenAL32/sample_cvt.c
diff options
context:
space:
mode:
Diffstat (limited to 'OpenAL32/sample_cvt.c')
-rw-r--r--OpenAL32/sample_cvt.c1113
1 files changed, 60 insertions, 1053 deletions
diff --git a/OpenAL32/sample_cvt.c b/OpenAL32/sample_cvt.c
index a02b217e..4a85f74a 100644
--- a/OpenAL32/sample_cvt.c
+++ b/OpenAL32/sample_cvt.c
@@ -3,13 +3,6 @@
#include "sample_cvt.h"
-#ifdef HAVE_ALLOCA_H
-#include <alloca.h>
-#endif
-#ifdef HAVE_MALLOC_H
-#include <malloc.h>
-#endif
-
#include "AL/al.h"
#include "alu.h"
#include "alBuffer.h"
@@ -61,7 +54,7 @@ static const int MSADPCMAdaptionCoeff[7][2] = {
/* A quick'n'dirty lookup table to decode a muLaw-encoded byte sample into a
* signed 16-bit sample */
-static const ALshort muLawDecompressionTable[256] = {
+const ALshort muLawDecompressionTable[256] = {
-32124,-31100,-30076,-29052,-28028,-27004,-25980,-24956,
-23932,-22908,-21884,-20860,-19836,-18812,-17788,-16764,
-15996,-15484,-14972,-14460,-13948,-13436,-12924,-12412,
@@ -96,32 +89,10 @@ static const ALshort muLawDecompressionTable[256] = {
56, 48, 40, 32, 24, 16, 8, 0
};
-/* Values used when encoding a muLaw sample */
-static const int muLawBias = 0x84;
-static const int muLawClip = 32635;
-static const char muLawCompressTable[256] = {
- 0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,
- 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
- 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
- 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
- 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
- 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
- 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
- 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
- 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
- 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
- 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
- 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
- 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
- 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
- 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
- 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
-};
-
/* A quick'n'dirty lookup table to decode an aLaw-encoded byte sample into a
* signed 16-bit sample */
-static const ALshort aLawDecompressionTable[256] = {
+const ALshort aLawDecompressionTable[256] = {
-5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736,
-7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784,
-2752, -2624, -3008, -2880, -2240, -2112, -2496, -2368,
@@ -156,92 +127,13 @@ static const ALshort aLawDecompressionTable[256] = {
944, 912, 1008, 976, 816, 784, 880, 848
};
-/* Values used when encoding an aLaw sample */
-static const int aLawClip = 32635;
-static const char aLawCompressTable[128] = {
- 1,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,
- 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
- 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
- 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
- 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
- 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
- 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
- 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
-};
-
-
-typedef ALubyte ALmulaw;
-typedef ALubyte ALalaw;
-typedef ALubyte ALima4;
-typedef ALubyte ALmsadpcm;
-typedef struct {
- ALbyte b[3];
-} ALbyte3;
-static_assert(sizeof(ALbyte3)==sizeof(ALbyte[3]), "ALbyte3 size is not 3");
-typedef struct {
- ALubyte b[3];
-} ALubyte3;
-static_assert(sizeof(ALubyte3)==sizeof(ALubyte[3]), "ALubyte3 size is not 3");
-
-static inline ALshort DecodeMuLaw(ALmulaw val)
-{ return muLawDecompressionTable[val]; }
-
-static ALmulaw EncodeMuLaw(ALshort val)
-{
- ALint mant, exp, sign;
-
- sign = (val>>8) & 0x80;
- if(sign)
- {
- /* -32768 doesn't properly negate on a short; it results in itself.
- * So clamp to -32767 */
- val = maxi(val, -32767);
- val = -val;
- }
-
- val = mini(val, muLawClip);
- val += muLawBias;
-
- exp = muLawCompressTable[(val>>7) & 0xff];
- mant = (val >> (exp+3)) & 0x0f;
- return ~(sign | (exp<<4) | mant);
-}
-
-static inline ALshort DecodeALaw(ALalaw val)
-{ return aLawDecompressionTable[val]; }
-
-static ALalaw EncodeALaw(ALshort val)
+static void DecodeIMA4Block(ALshort *dst, const ALubyte *src, ALint numchans, ALsizei align)
{
- ALint mant, exp, sign;
-
- sign = ((~val) >> 8) & 0x80;
- if(!sign)
- {
- val = maxi(val, -32767);
- val = -val;
- }
- val = mini(val, aLawClip);
-
- if(val >= 256)
- {
- exp = aLawCompressTable[(val>>8) & 0x7f];
- mant = (val >> (exp+3)) & 0x0f;
- }
- else
- {
- exp = 0;
- mant = val >> 4;
- }
-
- return ((exp<<4) | mant) ^ (sign^0x55);
-}
-
-static void DecodeIMA4Block(ALshort *dst, const ALima4 *src, ALint numchans, ALsizei align)
-{
- ALint sample[MAX_INPUT_CHANNELS], index[MAX_INPUT_CHANNELS];
- ALuint code[MAX_INPUT_CHANNELS];
- ALsizei j,k,c;
+ ALint sample[MAX_INPUT_CHANNELS] = { 0 };
+ ALint index[MAX_INPUT_CHANNELS] = { 0 };
+ ALuint code[MAX_INPUT_CHANNELS] = { 0 };
+ ALsizei c, i;
for(c = 0;c < numchans;c++)
{
@@ -257,143 +149,77 @@ static void DecodeIMA4Block(ALshort *dst, const ALima4 *src, ALint numchans, ALs
dst[c] = sample[c];
}
- for(j = 1;j < align;j += 8)
+ for(i = 1;i < align;i++)
{
- for(c = 0;c < numchans;c++)
- {
- code[c] = *(src++);
- code[c] |= *(src++) << 8;
- code[c] |= *(src++) << 16;
- code[c] |= *(src++) << 24;
- }
-
- for(k = 0;k < 8;k++)
+ if((i&7) == 1)
{
for(c = 0;c < numchans;c++)
{
- int nibble = code[c]&0xf;
- code[c] >>= 4;
-
- sample[c] += IMA4Codeword[nibble] * IMAStep_size[index[c]] / 8;
- sample[c] = clampi(sample[c], -32768, 32767);
-
- index[c] += IMA4Index_adjust[nibble];
- index[c] = clampi(index[c], 0, 88);
-
- dst[(j+k)*numchans + c] = sample[c];
+ code[c] = *(src++);
+ code[c] |= *(src++) << 8;
+ code[c] |= *(src++) << 16;
+ code[c] |= *(src++) << 24;
}
}
- }
-}
-static void EncodeIMA4Block(ALima4 *dst, const ALshort *src, ALint *sample, ALint *index, ALint numchans, ALsizei align)
-{
- ALsizei j,k,c;
-
- for(c = 0;c < numchans;c++)
- {
- int diff = src[c] - sample[c];
- int step = IMAStep_size[index[c]];
- int nibble;
-
- nibble = 0;
- if(diff < 0)
- {
- nibble = 0x8;
- diff = -diff;
- }
-
- diff = mini(step*2, diff);
- nibble |= (diff*8/step - 1) / 2;
-
- sample[c] += IMA4Codeword[nibble] * step / 8;
- sample[c] = clampi(sample[c], -32768, 32767);
-
- index[c] += IMA4Index_adjust[nibble];
- index[c] = clampi(index[c], 0, 88);
-
- *(dst++) = sample[c] & 0xff;
- *(dst++) = (sample[c]>>8) & 0xff;
- *(dst++) = index[c] & 0xff;
- *(dst++) = (index[c]>>8) & 0xff;
- }
-
- for(j = 1;j < align;j += 8)
- {
for(c = 0;c < numchans;c++)
{
- for(k = 0;k < 8;k++)
- {
- int diff = src[(j+k)*numchans + c] - sample[c];
- int step = IMAStep_size[index[c]];
- int nibble;
-
- nibble = 0;
- if(diff < 0)
- {
- nibble = 0x8;
- diff = -diff;
- }
+ int nibble = code[c]&0xf;
+ code[c] >>= 4;
- diff = mini(step*2, diff);
- nibble |= (diff*8/step - 1) / 2;
+ sample[c] += IMA4Codeword[nibble] * IMAStep_size[index[c]] / 8;
+ sample[c] = clampi(sample[c], -32768, 32767);
- sample[c] += IMA4Codeword[nibble] * step / 8;
- sample[c] = clampi(sample[c], -32768, 32767);
+ index[c] += IMA4Index_adjust[nibble];
+ index[c] = clampi(index[c], 0, 88);
- index[c] += IMA4Index_adjust[nibble];
- index[c] = clampi(index[c], 0, 88);
-
- if(!(k&1)) *dst = nibble;
- else *(dst++) |= nibble<<4;
- }
+ *(dst++) = sample[c];
}
}
}
-
-static void DecodeMSADPCMBlock(ALshort *dst, const ALmsadpcm *src, ALint numchans, ALsizei align)
+static void DecodeMSADPCMBlock(ALshort *dst, const ALubyte *src, ALint numchans, ALsizei align)
{
- ALubyte blockpred[MAX_INPUT_CHANNELS];
- ALint delta[MAX_INPUT_CHANNELS];
- ALshort samples[MAX_INPUT_CHANNELS][2];
- ALint i, j;
+ ALubyte blockpred[MAX_INPUT_CHANNELS] = { 0 };
+ ALint delta[MAX_INPUT_CHANNELS] = { 0 };
+ ALshort samples[MAX_INPUT_CHANNELS][2] = { { 0, 0 } };
+ ALint c, i;
- for(i = 0;i < numchans;i++)
+ for(c = 0;c < numchans;c++)
{
- blockpred[i] = *(src++);
- blockpred[i] = minu(blockpred[i], 6);
+ blockpred[c] = *(src++);
+ blockpred[c] = minu(blockpred[c], 6);
}
- for(i = 0;i < numchans;i++)
+ for(c = 0;c < numchans;c++)
{
- delta[i] = *(src++);
- delta[i] |= *(src++) << 8;
- delta[i] = (delta[i]^0x8000) - 0x8000;
+ delta[c] = *(src++);
+ delta[c] |= *(src++) << 8;
+ delta[c] = (delta[c]^0x8000) - 32768;
}
- for(i = 0;i < numchans;i++)
+ for(c = 0;c < numchans;c++)
{
- samples[i][0] = *(src++);
- samples[i][0] |= *(src++) << 8;
- samples[i][0] = (samples[i][0]^0x8000) - 0x8000;
+ samples[c][0] = *(src++);
+ samples[c][0] |= *(src++) << 8;
+ samples[c][0] = (samples[c][0]^0x8000) - 32768;
}
- for(i = 0;i < numchans;i++)
+ for(c = 0;c < numchans;c++)
{
- samples[i][1] = *(src++);
- samples[i][1] |= *(src++) << 8;
- samples[i][1] = (samples[i][1]^0x8000) - 0x8000;
+ samples[c][1] = *(src++);
+ samples[c][1] |= *(src++) << 8;
+ samples[c][1] = (samples[c][1]^0x8000) - 0x8000;
}
/* Second sample is written first. */
- for(i = 0;i < numchans;i++)
- *(dst++) = samples[i][1];
- for(i = 0;i < numchans;i++)
- *(dst++) = samples[i][0];
+ for(c = 0;c < numchans;c++)
+ *(dst++) = samples[c][1];
+ for(c = 0;c < numchans;c++)
+ *(dst++) = samples[c][0];
- for(j = 2;j < align;j++)
+ for(i = 2;i < align;i++)
{
- for(i = 0;i < numchans;i++)
+ for(c = 0;c < numchans;c++)
{
- const ALint num = (j*numchans) + i;
+ const ALint num = (i*numchans) + c;
ALint nibble, pred;
/* Read the nibble (first is in the upper bits). */
@@ -402,545 +228,28 @@ static void DecodeMSADPCMBlock(ALshort *dst, const ALmsadpcm *src, ALint numchan
else
nibble = (*(src++))&0x0f;
- pred = (samples[i][0]*MSADPCMAdaptionCoeff[blockpred[i]][0] +
- samples[i][1]*MSADPCMAdaptionCoeff[blockpred[i]][1]) / 256;
- pred += ((nibble^0x08) - 0x08) * delta[i];
+ pred = (samples[c][0]*MSADPCMAdaptionCoeff[blockpred[c]][0] +
+ samples[c][1]*MSADPCMAdaptionCoeff[blockpred[c]][1]) / 256;
+ pred += ((nibble^0x08) - 0x08) * delta[c];
pred = clampi(pred, -32768, 32767);
- samples[i][1] = samples[i][0];
- samples[i][0] = pred;
+ samples[c][1] = samples[c][0];
+ samples[c][0] = pred;
- delta[i] = (MSADPCMAdaption[nibble] * delta[i]) / 256;
- delta[i] = maxi(16, delta[i]);
+ delta[c] = (MSADPCMAdaption[nibble] * delta[c]) / 256;
+ delta[c] = maxi(16, delta[c]);
*(dst++) = pred;
}
}
}
-/* NOTE: This encoder is pretty dumb/simplistic. Some kind of pre-processing
- * that tries to find the optimal block predictors would be nice, at least. A
- * multi-pass method that can generate better deltas would be good, too. */
-static void EncodeMSADPCMBlock(ALmsadpcm *dst, const ALshort *src, ALint *sample, ALint numchans, ALsizei align)
-{
- ALubyte blockpred[MAX_INPUT_CHANNELS];
- ALint delta[MAX_INPUT_CHANNELS];
- ALshort samples[MAX_INPUT_CHANNELS][2];
- ALint i, j;
-
- /* Block predictor */
- for(i = 0;i < numchans;i++)
- {
- /* FIXME: Calculate something better. */
- blockpred[i] = 0;
- *(dst++) = blockpred[i];
- }
- /* Initial delta */
- for(i = 0;i < numchans;i++)
- {
- delta[i] = 16;
- *(dst++) = (delta[i] ) & 0xff;
- *(dst++) = (delta[i]>>8) & 0xff;
- }
- /* Initial sample 1 */
- for(i = 0;i < numchans;i++)
- {
- samples[i][0] = src[1*numchans + i];
- *(dst++) = (samples[i][0] ) & 0xff;
- *(dst++) = (samples[i][0]>>8) & 0xff;
- }
- /* Initial sample 2 */
- for(i = 0;i < numchans;i++)
- {
- samples[i][1] = src[i];
- *(dst++) = (samples[i][1] ) & 0xff;
- *(dst++) = (samples[i][1]>>8) & 0xff;
- }
-
- for(j = 2;j < align;j++)
- {
- for(i = 0;i < numchans;i++)
- {
- const ALint num = (j*numchans) + i;
- ALint nibble = 0;
- ALint bias;
-
- sample[i] = (samples[i][0]*MSADPCMAdaptionCoeff[blockpred[i]][0] +
- samples[i][1]*MSADPCMAdaptionCoeff[blockpred[i]][1]) / 256;
-
- nibble = src[num] - sample[i];
- if(nibble >= 0)
- bias = delta[i] / 2;
- else
- bias = -delta[i] / 2;
-
- nibble = (nibble + bias) / delta[i];
- nibble = clampi(nibble, -8, 7)&0x0f;
-
- sample[i] += ((nibble^0x08)-0x08) * delta[i];
- sample[i] = clampi(sample[i], -32768, 32767);
- samples[i][1] = samples[i][0];
- samples[i][0] = sample[i];
-
- delta[i] = (MSADPCMAdaption[nibble] * delta[i]) / 256;
- delta[i] = maxi(16, delta[i]);
-
- if(!(num&1))
- *dst = nibble << 4;
- else
- {
- *dst |= nibble;
- dst++;
- }
- }
- }
-}
-
-
-static inline ALint DecodeByte3(ALbyte3 val)
-{
- if(IS_LITTLE_ENDIAN)
- return (val.b[2]<<16) | (((ALubyte)val.b[1])<<8) | ((ALubyte)val.b[0]);
- return (val.b[0]<<16) | (((ALubyte)val.b[1])<<8) | ((ALubyte)val.b[2]);
-}
-
-static inline ALbyte3 EncodeByte3(ALint val)
-{
- if(IS_LITTLE_ENDIAN)
- {
- ALbyte3 ret = {{ val, val>>8, val>>16 }};
- return ret;
- }
- else
- {
- ALbyte3 ret = {{ val>>16, val>>8, val }};
- return ret;
- }
-}
-
-static inline ALint DecodeUByte3(ALubyte3 val)
-{
- if(IS_LITTLE_ENDIAN)
- return (val.b[2]<<16) | (val.b[1]<<8) | (val.b[0]);
- return (val.b[0]<<16) | (val.b[1]<<8) | val.b[2];
-}
-
-static inline ALubyte3 EncodeUByte3(ALint val)
-{
- if(IS_LITTLE_ENDIAN)
- {
- ALubyte3 ret = {{ val, val>>8, val>>16 }};
- return ret;
- }
- else
- {
- ALubyte3 ret = {{ val>>16, val>>8, val }};
- return ret;
- }
-}
-
-
-static inline ALbyte Conv_ALbyte_ALbyte(ALbyte val)
-{ return val; }
-static inline ALbyte Conv_ALbyte_ALubyte(ALubyte val)
-{ return val-128; }
-static inline ALbyte Conv_ALbyte_ALshort(ALshort val)
-{ return val>>8; }
-static inline ALbyte Conv_ALbyte_ALushort(ALushort val)
-{ return (val>>8)-128; }
-static inline ALbyte Conv_ALbyte_ALint(ALint val)
-{ return val>>24; }
-static inline ALbyte Conv_ALbyte_ALuint(ALuint val)
-{ return (val>>24)-128; }
-static inline ALbyte Conv_ALbyte_ALfloat(ALfloat val)
-{
- if(val > 1.0f) return 127;
- if(val < -1.0f) return -128;
- return (ALint)(val * 127.0f);
-}
-static inline ALbyte Conv_ALbyte_ALdouble(ALdouble val)
-{
- if(val > 1.0) return 127;
- if(val < -1.0) return -128;
- return (ALint)(val * 127.0);
-}
-static inline ALbyte Conv_ALbyte_ALmulaw(ALmulaw val)
-{ return Conv_ALbyte_ALshort(DecodeMuLaw(val)); }
-static inline ALbyte Conv_ALbyte_ALalaw(ALalaw val)
-{ return Conv_ALbyte_ALshort(DecodeALaw(val)); }
-static inline ALbyte Conv_ALbyte_ALbyte3(ALbyte3 val)
-{ return DecodeByte3(val)>>16; }
-static inline ALbyte Conv_ALbyte_ALubyte3(ALubyte3 val)
-{ return (DecodeUByte3(val)>>16)-128; }
-
-static inline ALubyte Conv_ALubyte_ALbyte(ALbyte val)
-{ return val+128; }
-static inline ALubyte Conv_ALubyte_ALubyte(ALubyte val)
-{ return val; }
-static inline ALubyte Conv_ALubyte_ALshort(ALshort val)
-{ return (val>>8)+128; }
-static inline ALubyte Conv_ALubyte_ALushort(ALushort val)
-{ return val>>8; }
-static inline ALubyte Conv_ALubyte_ALint(ALint val)
-{ return (val>>24)+128; }
-static inline ALubyte Conv_ALubyte_ALuint(ALuint val)
-{ return val>>24; }
-static inline ALubyte Conv_ALubyte_ALfloat(ALfloat val)
-{
- if(val > 1.0f) return 255;
- if(val < -1.0f) return 0;
- return (ALint)(val * 127.0f) + 128;
-}
-static inline ALubyte Conv_ALubyte_ALdouble(ALdouble val)
-{
- if(val > 1.0) return 255;
- if(val < -1.0) return 0;
- return (ALint)(val * 127.0) + 128;
-}
-static inline ALubyte Conv_ALubyte_ALmulaw(ALmulaw val)
-{ return Conv_ALubyte_ALshort(DecodeMuLaw(val)); }
-static inline ALubyte Conv_ALubyte_ALalaw(ALalaw val)
-{ return Conv_ALubyte_ALshort(DecodeALaw(val)); }
-static inline ALubyte Conv_ALubyte_ALbyte3(ALbyte3 val)
-{ return (DecodeByte3(val)>>16)+128; }
-static inline ALubyte Conv_ALubyte_ALubyte3(ALubyte3 val)
-{ return DecodeUByte3(val)>>16; }
-
-static inline ALshort Conv_ALshort_ALbyte(ALbyte val)
-{ return val<<8; }
-static inline ALshort Conv_ALshort_ALubyte(ALubyte val)
-{ return (val-128)<<8; }
-static inline ALshort Conv_ALshort_ALshort(ALshort val)
-{ return val; }
-static inline ALshort Conv_ALshort_ALushort(ALushort val)
-{ return val-32768; }
-static inline ALshort Conv_ALshort_ALint(ALint val)
-{ return val>>16; }
-static inline ALshort Conv_ALshort_ALuint(ALuint val)
-{ return (val>>16)-32768; }
-static inline ALshort Conv_ALshort_ALfloat(ALfloat val)
-{
- if(val > 1.0f) return 32767;
- if(val < -1.0f) return -32768;
- return (ALint)(val * 32767.0f);
-}
-static inline ALshort Conv_ALshort_ALdouble(ALdouble val)
-{
- if(val > 1.0) return 32767;
- if(val < -1.0) return -32768;
- return (ALint)(val * 32767.0);
-}
-static inline ALshort Conv_ALshort_ALmulaw(ALmulaw val)
-{ return Conv_ALshort_ALshort(DecodeMuLaw(val)); }
-static inline ALshort Conv_ALshort_ALalaw(ALalaw val)
-{ return Conv_ALshort_ALshort(DecodeALaw(val)); }
-static inline ALshort Conv_ALshort_ALbyte3(ALbyte3 val)
-{ return DecodeByte3(val)>>8; }
-static inline ALshort Conv_ALshort_ALubyte3(ALubyte3 val)
-{ return (DecodeUByte3(val)>>8)-32768; }
-
-static inline ALushort Conv_ALushort_ALbyte(ALbyte val)
-{ return (val+128)<<8; }
-static inline ALushort Conv_ALushort_ALubyte(ALubyte val)
-{ return val<<8; }
-static inline ALushort Conv_ALushort_ALshort(ALshort val)
-{ return val+32768; }
-static inline ALushort Conv_ALushort_ALushort(ALushort val)
-{ return val; }
-static inline ALushort Conv_ALushort_ALint(ALint val)
-{ return (val>>16)+32768; }
-static inline ALushort Conv_ALushort_ALuint(ALuint val)
-{ return val>>16; }
-static inline ALushort Conv_ALushort_ALfloat(ALfloat val)
-{
- if(val > 1.0f) return 65535;
- if(val < -1.0f) return 0;
- return (ALint)(val * 32767.0f) + 32768;
-}
-static inline ALushort Conv_ALushort_ALdouble(ALdouble val)
-{
- if(val > 1.0) return 65535;
- if(val < -1.0) return 0;
- return (ALint)(val * 32767.0) + 32768;
-}
-static inline ALushort Conv_ALushort_ALmulaw(ALmulaw val)
-{ return Conv_ALushort_ALshort(DecodeMuLaw(val)); }
-static inline ALushort Conv_ALushort_ALalaw(ALalaw val)
-{ return Conv_ALushort_ALshort(DecodeALaw(val)); }
-static inline ALushort Conv_ALushort_ALbyte3(ALbyte3 val)
-{ return (DecodeByte3(val)>>8)+32768; }
-static inline ALushort Conv_ALushort_ALubyte3(ALubyte3 val)
-{ return DecodeUByte3(val)>>8; }
-
-static inline ALint Conv_ALint_ALbyte(ALbyte val)
-{ return val<<24; }
-static inline ALint Conv_ALint_ALubyte(ALubyte val)
-{ return (val-128)<<24; }
-static inline ALint Conv_ALint_ALshort(ALshort val)
-{ return val<<16; }
-static inline ALint Conv_ALint_ALushort(ALushort val)
-{ return (val-32768)<<16; }
-static inline ALint Conv_ALint_ALint(ALint val)
-{ return val; }
-static inline ALint Conv_ALint_ALuint(ALuint val)
-{ return val-2147483648u; }
-static inline ALint Conv_ALint_ALfloat(ALfloat val)
-{
- if(val > 1.0f) return 2147483647;
- if(val < -1.0f) return -2147483647-1;
- return (ALint)(val*16777215.0f) << 7;
-}
-static inline ALint Conv_ALint_ALdouble(ALdouble val)
-{
- if(val > 1.0) return 2147483647;
- if(val < -1.0) return -2147483647-1;
- return (ALint)(val * 2147483647.0);
-}
-static inline ALint Conv_ALint_ALmulaw(ALmulaw val)
-{ return Conv_ALint_ALshort(DecodeMuLaw(val)); }
-static inline ALint Conv_ALint_ALalaw(ALalaw val)
-{ return Conv_ALint_ALshort(DecodeALaw(val)); }
-static inline ALint Conv_ALint_ALbyte3(ALbyte3 val)
-{ return DecodeByte3(val)<<8; }
-static inline ALint Conv_ALint_ALubyte3(ALubyte3 val)
-{ return (DecodeUByte3(val)-8388608)<<8; }
-
-static inline ALuint Conv_ALuint_ALbyte(ALbyte val)
-{ return (val+128)<<24; }
-static inline ALuint Conv_ALuint_ALubyte(ALubyte val)
-{ return val<<24; }
-static inline ALuint Conv_ALuint_ALshort(ALshort val)
-{ return (val+32768)<<16; }
-static inline ALuint Conv_ALuint_ALushort(ALushort val)
-{ return val<<16; }
-static inline ALuint Conv_ALuint_ALint(ALint val)
-{ return val+2147483648u; }
-static inline ALuint Conv_ALuint_ALuint(ALuint val)
-{ return val; }
-static inline ALuint Conv_ALuint_ALfloat(ALfloat val)
-{
- if(val > 1.0f) return 4294967295u;
- if(val < -1.0f) return 0;
- return ((ALint)(val*16777215.0f)<<7) + 2147483648u;
-}
-static inline ALuint Conv_ALuint_ALdouble(ALdouble val)
-{
- if(val > 1.0) return 4294967295u;
- if(val < -1.0) return 0;
- return (ALint)(val * 2147483647.0) + 2147483648u;
-}
-static inline ALuint Conv_ALuint_ALmulaw(ALmulaw val)
-{ return Conv_ALuint_ALshort(DecodeMuLaw(val)); }
-static inline ALuint Conv_ALuint_ALalaw(ALalaw val)
-{ return Conv_ALuint_ALshort(DecodeALaw(val)); }
-static inline ALuint Conv_ALuint_ALbyte3(ALbyte3 val)
-{ return (DecodeByte3(val)+8388608)<<8; }
-static inline ALuint Conv_ALuint_ALubyte3(ALubyte3 val)
-{ return DecodeUByte3(val)<<8; }
-
-static inline ALfloat Conv_ALfloat_ALbyte(ALbyte val)
-{ return val * (1.0f/127.0f); }
-static inline ALfloat Conv_ALfloat_ALubyte(ALubyte val)
-{ return (val-128) * (1.0f/127.0f); }
-static inline ALfloat Conv_ALfloat_ALshort(ALshort val)
-{ return val * (1.0f/32767.0f); }
-static inline ALfloat Conv_ALfloat_ALushort(ALushort val)
-{ return (val-32768) * (1.0f/32767.0f); }
-static inline ALfloat Conv_ALfloat_ALint(ALint val)
-{ return (ALfloat)(val>>7) * (1.0f/16777215.0f); }
-static inline ALfloat Conv_ALfloat_ALuint(ALuint val)
-{ return (ALfloat)((ALint)(val>>7)-16777216) * (1.0f/16777215.0f); }
-static inline ALfloat Conv_ALfloat_ALfloat(ALfloat val)
-{ return (val==val) ? val : 0.0f; }
-static inline ALfloat Conv_ALfloat_ALdouble(ALdouble val)
-{ return (val==val) ? (ALfloat)val : 0.0f; }
-static inline ALfloat Conv_ALfloat_ALmulaw(ALmulaw val)
-{ return Conv_ALfloat_ALshort(DecodeMuLaw(val)); }
-static inline ALfloat Conv_ALfloat_ALalaw(ALalaw val)
-{ return Conv_ALfloat_ALshort(DecodeALaw(val)); }
-static inline ALfloat Conv_ALfloat_ALbyte3(ALbyte3 val)
-{ return (ALfloat)(DecodeByte3(val) * (1.0/8388607.0)); }
-static inline ALfloat Conv_ALfloat_ALubyte3(ALubyte3 val)
-{ return (ALfloat)((DecodeUByte3(val)-8388608) * (1.0/8388607.0)); }
-
-static inline ALdouble Conv_ALdouble_ALbyte(ALbyte val)
-{ return val * (1.0/127.0); }
-static inline ALdouble Conv_ALdouble_ALubyte(ALubyte val)
-{ return (val-128) * (1.0/127.0); }
-static inline ALdouble Conv_ALdouble_ALshort(ALshort val)
-{ return val * (1.0/32767.0); }
-static inline ALdouble Conv_ALdouble_ALushort(ALushort val)
-{ return (val-32768) * (1.0/32767.0); }
-static inline ALdouble Conv_ALdouble_ALint(ALint val)
-{ return val * (1.0/2147483647.0); }
-static inline ALdouble Conv_ALdouble_ALuint(ALuint val)
-{ return (ALint)(val-2147483648u) * (1.0/2147483647.0); }
-static inline ALdouble Conv_ALdouble_ALfloat(ALfloat val)
-{ return (val==val) ? val : 0.0f; }
-static inline ALdouble Conv_ALdouble_ALdouble(ALdouble val)
-{ return (val==val) ? val : 0.0; }
-static inline ALdouble Conv_ALdouble_ALmulaw(ALmulaw val)
-{ return Conv_ALdouble_ALshort(DecodeMuLaw(val)); }
-static inline ALdouble Conv_ALdouble_ALalaw(ALalaw val)
-{ return Conv_ALdouble_ALshort(DecodeALaw(val)); }
-static inline ALdouble Conv_ALdouble_ALbyte3(ALbyte3 val)
-{ return DecodeByte3(val) * (1.0/8388607.0); }
-static inline ALdouble Conv_ALdouble_ALubyte3(ALubyte3 val)
-{ return (DecodeUByte3(val)-8388608) * (1.0/8388607.0); }
-
-#define DECL_TEMPLATE(T) \
-static inline ALmulaw Conv_ALmulaw_##T(T val) \
-{ return EncodeMuLaw(Conv_ALshort_##T(val)); }
-
-DECL_TEMPLATE(ALbyte)
-DECL_TEMPLATE(ALubyte)
-DECL_TEMPLATE(ALshort)
-DECL_TEMPLATE(ALushort)
-DECL_TEMPLATE(ALint)
-DECL_TEMPLATE(ALuint)
-DECL_TEMPLATE(ALfloat)
-DECL_TEMPLATE(ALdouble)
-static inline ALmulaw Conv_ALmulaw_ALmulaw(ALmulaw val)
-{ return val; }
-DECL_TEMPLATE(ALalaw)
-DECL_TEMPLATE(ALbyte3)
-DECL_TEMPLATE(ALubyte3)
-
-#undef DECL_TEMPLATE
-
-#define DECL_TEMPLATE(T) \
-static inline ALalaw Conv_ALalaw_##T(T val) \
-{ return EncodeALaw(Conv_ALshort_##T(val)); }
-
-DECL_TEMPLATE(ALbyte)
-DECL_TEMPLATE(ALubyte)
-DECL_TEMPLATE(ALshort)
-DECL_TEMPLATE(ALushort)
-DECL_TEMPLATE(ALint)
-DECL_TEMPLATE(ALuint)
-DECL_TEMPLATE(ALfloat)
-DECL_TEMPLATE(ALdouble)
-DECL_TEMPLATE(ALmulaw)
-static inline ALalaw Conv_ALalaw_ALalaw(ALalaw val)
-{ return val; }
-DECL_TEMPLATE(ALbyte3)
-DECL_TEMPLATE(ALubyte3)
-
-#undef DECL_TEMPLATE
-
-#define DECL_TEMPLATE(T) \
-static inline ALbyte3 Conv_ALbyte3_##T(T val) \
-{ return EncodeByte3(Conv_ALint_##T(val)>>8); }
-
-DECL_TEMPLATE(ALbyte)
-DECL_TEMPLATE(ALubyte)
-DECL_TEMPLATE(ALshort)
-DECL_TEMPLATE(ALushort)
-DECL_TEMPLATE(ALint)
-DECL_TEMPLATE(ALuint)
-DECL_TEMPLATE(ALfloat)
-DECL_TEMPLATE(ALdouble)
-DECL_TEMPLATE(ALmulaw)
-DECL_TEMPLATE(ALalaw)
-static inline ALbyte3 Conv_ALbyte3_ALbyte3(ALbyte3 val)
-{ return val; }
-DECL_TEMPLATE(ALubyte3)
-
-#undef DECL_TEMPLATE
-
-#define DECL_TEMPLATE(T) \
-static inline ALubyte3 Conv_ALubyte3_##T(T val) \
-{ return EncodeUByte3(Conv_ALuint_##T(val)>>8); }
-
-DECL_TEMPLATE(ALbyte)
-DECL_TEMPLATE(ALubyte)
-DECL_TEMPLATE(ALshort)
-DECL_TEMPLATE(ALushort)
-DECL_TEMPLATE(ALint)
-DECL_TEMPLATE(ALuint)
-DECL_TEMPLATE(ALfloat)
-DECL_TEMPLATE(ALdouble)
-DECL_TEMPLATE(ALmulaw)
-DECL_TEMPLATE(ALalaw)
-DECL_TEMPLATE(ALbyte3)
-static inline ALubyte3 Conv_ALubyte3_ALubyte3(ALubyte3 val)
-{ return val; }
-
-#undef DECL_TEMPLATE
-
-
-#define DECL_TEMPLATE(T1, T2) \
-static void Convert_##T1##_##T2(T1 *dst, const T2 *src, ALuint numchans, \
- ALuint len, ALsizei UNUSED(align)) \
-{ \
- ALuint i, j; \
- for(i = 0;i < len;i++) \
- { \
- for(j = 0;j < numchans;j++) \
- *(dst++) = Conv_##T1##_##T2(*(src++)); \
- } \
-}
-
-#define DECL_TEMPLATE2(T) \
-DECL_TEMPLATE(T, ALbyte) \
-DECL_TEMPLATE(T, ALubyte) \
-DECL_TEMPLATE(T, ALshort) \
-DECL_TEMPLATE(T, ALushort) \
-DECL_TEMPLATE(T, ALint) \
-DECL_TEMPLATE(T, ALuint) \
-DECL_TEMPLATE(T, ALfloat) \
-DECL_TEMPLATE(T, ALdouble) \
-DECL_TEMPLATE(T, ALmulaw) \
-DECL_TEMPLATE(T, ALalaw) \
-DECL_TEMPLATE(T, ALbyte3) \
-DECL_TEMPLATE(T, ALubyte3)
-
-DECL_TEMPLATE2(ALbyte)
-DECL_TEMPLATE2(ALubyte)
-DECL_TEMPLATE2(ALshort)
-DECL_TEMPLATE2(ALushort)
-DECL_TEMPLATE2(ALint)
-DECL_TEMPLATE2(ALuint)
-DECL_TEMPLATE2(ALfloat)
-DECL_TEMPLATE2(ALdouble)
-DECL_TEMPLATE2(ALmulaw)
-DECL_TEMPLATE2(ALalaw)
-DECL_TEMPLATE2(ALbyte3)
-DECL_TEMPLATE2(ALubyte3)
-
-#undef DECL_TEMPLATE2
-#undef DECL_TEMPLATE
-
-#define DECL_TEMPLATE(T) \
-static void Convert_##T##_ALima4(T *dst, const ALima4 *src, ALuint numchans, \
- ALuint len, ALuint align) \
-{ \
- ALsizei byte_align = ((align-1)/2 + 4) * numchans; \
- DECL_VLA(ALshort, tmp, align*numchans); \
- ALuint i, j, k; \
- \
- assert(align > 0 && (len%align) == 0); \
- for(i = 0;i < len;i += align) \
- { \
- DecodeIMA4Block(tmp, src, numchans, align); \
- src += byte_align; \
- \
- for(j = 0;j < align;j++) \
- { \
- for(k = 0;k < numchans;k++) \
- *(dst++) = Conv_##T##_ALshort(tmp[j*numchans + k]); \
- } \
- } \
-}
-
-DECL_TEMPLATE(ALbyte)
-DECL_TEMPLATE(ALubyte)
-static void Convert_ALshort_ALima4(ALshort *dst, const ALima4 *src, ALuint numchans,
- ALuint len, ALuint align)
+void Convert_ALshort_ALima4(ALshort *dst, const ALubyte *src, ALsizei numchans, ALsizei len,
+ ALsizei align)
{
ALsizei byte_align = ((align-1)/2 + 4) * numchans;
- ALuint i;
+ ALsizei i;
assert(align > 0 && (len%align) == 0);
for(i = 0;i < len;i += align)
@@ -950,103 +259,12 @@ static void Convert_ALshort_ALima4(ALshort *dst, const ALima4 *src, ALuint numch
dst += align*numchans;
}
}
-DECL_TEMPLATE(ALushort)
-DECL_TEMPLATE(ALint)
-DECL_TEMPLATE(ALuint)
-DECL_TEMPLATE(ALfloat)
-DECL_TEMPLATE(ALdouble)
-DECL_TEMPLATE(ALmulaw)
-DECL_TEMPLATE(ALalaw)
-DECL_TEMPLATE(ALbyte3)
-DECL_TEMPLATE(ALubyte3)
-#undef DECL_TEMPLATE
-
-#define DECL_TEMPLATE(T) \
-static void Convert_ALima4_##T(ALima4 *dst, const T *src, ALuint numchans, \
- ALuint len, ALuint align) \
-{ \
- ALint sample[MAX_INPUT_CHANNELS] = {0,0,0,0,0,0,0,0}; \
- ALint index[MAX_INPUT_CHANNELS] = {0,0,0,0,0,0,0,0}; \
- ALsizei byte_align = ((align-1)/2 + 4) * numchans; \
- DECL_VLA(ALshort, tmp, align*numchans); \
- ALuint i, j, k; \
- \
- assert(align > 0 && (len%align) == 0); \
- for(i = 0;i < len;i += align) \
- { \
- for(j = 0;j < align;j++) \
- { \
- for(k = 0;k < numchans;k++) \
- tmp[j*numchans + k] = Conv_ALshort_##T(*(src++)); \
- } \
- EncodeIMA4Block(dst, tmp, sample, index, numchans, align); \
- dst += byte_align; \
- } \
-}
-
-DECL_TEMPLATE(ALbyte)
-DECL_TEMPLATE(ALubyte)
-static void Convert_ALima4_ALshort(ALima4 *dst, const ALshort *src,
- ALuint numchans, ALuint len, ALuint align)
-{
- ALint sample[MAX_INPUT_CHANNELS] = {0,0,0,0,0,0,0,0};
- ALint index[MAX_INPUT_CHANNELS] = {0,0,0,0,0,0,0,0};
- ALsizei byte_align = ((align-1)/2 + 4) * numchans;
- ALuint i;
-
- assert(align > 0 && (len%align) == 0);
- for(i = 0;i < len;i += align)
- {
- EncodeIMA4Block(dst, src, sample, index, numchans, align);
- src += align*numchans;
- dst += byte_align;
- }
-}
-DECL_TEMPLATE(ALushort)
-DECL_TEMPLATE(ALint)
-DECL_TEMPLATE(ALuint)
-DECL_TEMPLATE(ALfloat)
-DECL_TEMPLATE(ALdouble)
-DECL_TEMPLATE(ALmulaw)
-DECL_TEMPLATE(ALalaw)
-DECL_TEMPLATE(ALbyte3)
-DECL_TEMPLATE(ALubyte3)
-
-#undef DECL_TEMPLATE
-
-
-#define DECL_TEMPLATE(T) \
-static void Convert_##T##_ALmsadpcm(T *dst, const ALmsadpcm *src, \
- ALuint numchans, ALuint len, \
- ALuint align) \
-{ \
- ALsizei byte_align = ((align-2)/2 + 7) * numchans; \
- DECL_VLA(ALshort, tmp, align*numchans); \
- ALuint i, j, k; \
- \
- assert(align > 1 && (len%align) == 0); \
- for(i = 0;i < len;i += align) \
- { \
- DecodeMSADPCMBlock(tmp, src, numchans, align); \
- src += byte_align; \
- \
- for(j = 0;j < align;j++) \
- { \
- for(k = 0;k < numchans;k++) \
- *(dst++) = Conv_##T##_ALshort(tmp[j*numchans + k]); \
- } \
- } \
-}
-
-DECL_TEMPLATE(ALbyte)
-DECL_TEMPLATE(ALubyte)
-static void Convert_ALshort_ALmsadpcm(ALshort *dst, const ALmsadpcm *src,
- ALuint numchans, ALuint len,
- ALuint align)
+void Convert_ALshort_ALmsadpcm(ALshort *dst, const ALubyte *src, ALsizei numchans, ALsizei len,
+ ALsizei align)
{
ALsizei byte_align = ((align-2)/2 + 7) * numchans;
- ALuint i;
+ ALsizei i;
assert(align > 1 && (len%align) == 0);
for(i = 0;i < len;i += align)
@@ -1056,214 +274,3 @@ static void Convert_ALshort_ALmsadpcm(ALshort *dst, const ALmsadpcm *src,
dst += align*numchans;
}
}
-DECL_TEMPLATE(ALushort)
-DECL_TEMPLATE(ALint)
-DECL_TEMPLATE(ALuint)
-DECL_TEMPLATE(ALfloat)
-DECL_TEMPLATE(ALdouble)
-DECL_TEMPLATE(ALmulaw)
-DECL_TEMPLATE(ALalaw)
-DECL_TEMPLATE(ALbyte3)
-DECL_TEMPLATE(ALubyte3)
-
-#undef DECL_TEMPLATE
-
-#define DECL_TEMPLATE(T) \
-static void Convert_ALmsadpcm_##T(ALmsadpcm *dst, const T *src, \
- ALuint numchans, ALuint len, ALuint align) \
-{ \
- ALint sample[MAX_INPUT_CHANNELS] = {0,0,0,0,0,0,0,0}; \
- ALsizei byte_align = ((align-2)/2 + 7) * numchans; \
- DECL_VLA(ALshort, tmp, align*numchans); \
- ALuint i, j, k; \
- \
- assert(align > 1 && (len%align) == 0); \
- for(i = 0;i < len;i += align) \
- { \
- for(j = 0;j < align;j++) \
- { \
- for(k = 0;k < numchans;k++) \
- tmp[j*numchans + k] = Conv_ALshort_##T(*(src++)); \
- } \
- EncodeMSADPCMBlock(dst, tmp, sample, numchans, align); \
- dst += byte_align; \
- } \
-}
-
-DECL_TEMPLATE(ALbyte)
-DECL_TEMPLATE(ALubyte)
-static void Convert_ALmsadpcm_ALshort(ALmsadpcm *dst, const ALshort *src,
- ALuint numchans, ALuint len, ALuint align)
-{
- ALint sample[MAX_INPUT_CHANNELS] = {0,0,0,0,0,0,0,0};
- ALsizei byte_align = ((align-2)/2 + 7) * numchans;
- ALuint i;
-
- assert(align > 1 && (len%align) == 0);
- for(i = 0;i < len;i += align)
- {
- EncodeMSADPCMBlock(dst, src, sample, numchans, align);
- src += align*numchans;
- dst += byte_align;
- }
-}
-DECL_TEMPLATE(ALushort)
-DECL_TEMPLATE(ALint)
-DECL_TEMPLATE(ALuint)
-DECL_TEMPLATE(ALfloat)
-DECL_TEMPLATE(ALdouble)
-DECL_TEMPLATE(ALmulaw)
-DECL_TEMPLATE(ALalaw)
-DECL_TEMPLATE(ALbyte3)
-DECL_TEMPLATE(ALubyte3)
-
-#undef DECL_TEMPLATE
-
-/* NOTE: We don't store compressed samples internally, so these conversions
- * should never happen. */
-static void Convert_ALima4_ALima4(ALima4* UNUSED(dst), const ALima4* UNUSED(src),
- ALuint UNUSED(numchans), ALuint UNUSED(len),
- ALuint UNUSED(align))
-{
- ERR("Unexpected IMA4-to-IMA4 conversion!\n");
-}
-
-static void Convert_ALmsadpcm_ALmsadpcm(ALmsadpcm* UNUSED(dst), const ALmsadpcm* UNUSED(src),
- ALuint UNUSED(numchans), ALuint UNUSED(len),
- ALuint UNUSED(align))
-{
- ERR("Unexpected MSADPCM-to-MSADPCM conversion!\n");
-}
-
-static void Convert_ALmsadpcm_ALima4(ALmsadpcm* UNUSED(dst), const ALima4* UNUSED(src),
- ALuint UNUSED(numchans), ALuint UNUSED(len),
- ALuint UNUSED(align))
-{
- ERR("Unexpected IMA4-to-MSADPCM conversion!\n");
-}
-
-static void Convert_ALima4_ALmsadpcm(ALima4* UNUSED(dst), const ALmsadpcm* UNUSED(src),
- ALuint UNUSED(numchans), ALuint UNUSED(len),
- ALuint UNUSED(align))
-{
- ERR("Unexpected MSADPCM-to-IMA4 conversion!\n");
-}
-
-
-#define DECL_TEMPLATE(T) \
-static void Convert_##T(T *dst, const ALvoid *src, enum UserFmtType srcType, \
- ALsizei numchans, ALsizei len, ALsizei align) \
-{ \
- switch(srcType) \
- { \
- case UserFmtByte: \
- Convert_##T##_ALbyte(dst, src, numchans, len, align); \
- break; \
- case UserFmtUByte: \
- Convert_##T##_ALubyte(dst, src, numchans, len, align); \
- break; \
- case UserFmtShort: \
- Convert_##T##_ALshort(dst, src, numchans, len, align); \
- break; \
- case UserFmtUShort: \
- Convert_##T##_ALushort(dst, src, numchans, len, align); \
- break; \
- case UserFmtInt: \
- Convert_##T##_ALint(dst, src, numchans, len, align); \
- break; \
- case UserFmtUInt: \
- Convert_##T##_ALuint(dst, src, numchans, len, align); \
- break; \
- case UserFmtFloat: \
- Convert_##T##_ALfloat(dst, src, numchans, len, align); \
- break; \
- case UserFmtDouble: \
- Convert_##T##_ALdouble(dst, src, numchans, len, align); \
- break; \
- case UserFmtMulaw: \
- Convert_##T##_ALmulaw(dst, src, numchans, len, align); \
- break; \
- case UserFmtAlaw: \
- Convert_##T##_ALalaw(dst, src, numchans, len, align); \
- break; \
- case UserFmtIMA4: \
- Convert_##T##_ALima4(dst, src, numchans, len, align); \
- break; \
- case UserFmtMSADPCM: \
- Convert_##T##_ALmsadpcm(dst, src, numchans, len, align); \
- break; \
- case UserFmtByte3: \
- Convert_##T##_ALbyte3(dst, src, numchans, len, align); \
- break; \
- case UserFmtUByte3: \
- Convert_##T##_ALubyte3(dst, src, numchans, len, align); \
- break; \
- } \
-}
-
-DECL_TEMPLATE(ALbyte)
-DECL_TEMPLATE(ALubyte)
-DECL_TEMPLATE(ALshort)
-DECL_TEMPLATE(ALushort)
-DECL_TEMPLATE(ALint)
-DECL_TEMPLATE(ALuint)
-DECL_TEMPLATE(ALfloat)
-DECL_TEMPLATE(ALdouble)
-DECL_TEMPLATE(ALmulaw)
-DECL_TEMPLATE(ALalaw)
-DECL_TEMPLATE(ALima4)
-DECL_TEMPLATE(ALmsadpcm)
-DECL_TEMPLATE(ALbyte3)
-DECL_TEMPLATE(ALubyte3)
-
-#undef DECL_TEMPLATE
-
-
-void ConvertData(ALvoid *dst, enum UserFmtType dstType, const ALvoid *src, enum UserFmtType srcType, ALsizei numchans, ALsizei len, ALsizei align)
-{
- switch(dstType)
- {
- case UserFmtByte:
- Convert_ALbyte(dst, src, srcType, numchans, len, align);
- break;
- case UserFmtUByte:
- Convert_ALubyte(dst, src, srcType, numchans, len, align);
- break;
- case UserFmtShort:
- Convert_ALshort(dst, src, srcType, numchans, len, align);
- break;
- case UserFmtUShort:
- Convert_ALushort(dst, src, srcType, numchans, len, align);
- break;
- case UserFmtInt:
- Convert_ALint(dst, src, srcType, numchans, len, align);
- break;
- case UserFmtUInt:
- Convert_ALuint(dst, src, srcType, numchans, len, align);
- break;
- case UserFmtFloat:
- Convert_ALfloat(dst, src, srcType, numchans, len, align);
- break;
- case UserFmtDouble:
- Convert_ALdouble(dst, src, srcType, numchans, len, align);
- break;
- case UserFmtMulaw:
- Convert_ALmulaw(dst, src, srcType, numchans, len, align);
- break;
- case UserFmtAlaw:
- Convert_ALalaw(dst, src, srcType, numchans, len, align);
- break;
- case UserFmtIMA4:
- Convert_ALima4(dst, src, srcType, numchans, len, align);
- break;
- case UserFmtMSADPCM:
- Convert_ALmsadpcm(dst, src, srcType, numchans, len, align);
- break;
- case UserFmtByte3:
- Convert_ALbyte3(dst, src, srcType, numchans, len, align);
- break;
- case UserFmtUByte3:
- Convert_ALubyte3(dst, src, srcType, numchans, len, align);
- break;
- }
-}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-01 05:27:08 +0000