kcat/openal-soft
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

More cleanup for buffer loading

Browse Source 
Don't bother with unnecessary and unused converters, and remove some
unsupported queries.
This commit is contained in:
Chris Robinson 2018-01-21 23:35:28 -08:00
parent db13af1935
commit 5f3ae527c9
6 changed files with 112 additions and 833 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Alc/ALc.c
View File

@ -475,10 +475,6 @@ static const struct {
DECL(AL_BITS),
DECL(AL_CHANNELS),
DECL(AL_SIZE),
DECL(AL_INTERNAL_FORMAT_SOFT),
DECL(AL_BYTE_LENGTH_SOFT),
DECL(AL_SAMPLE_LENGTH_SOFT),
DECL(AL_SEC_LENGTH_SOFT),
DECL(AL_UNPACK_BLOCK_ALIGNMENT_SOFT),
DECL(AL_PACK_BLOCK_ALIGNMENT_SOFT),

14
OpenAL32/Include/alBuffer.h
View File

@ -71,19 +71,17 @@ inline ALsizei FrameSizeFromFmt(enum FmtChannels chans, enum FmtType type)
typedef struct ALbuffer {
ALvoid *data;
ALsizei Frequency;
ALenum Format;
ALsizei Frequency;
ALbitfieldSOFT Access;
ALsizei SampleLen;
ALsizei SampleLen;
enum FmtChannels FmtChannels;
enum FmtType FmtType;
ALuint BytesAlloc;
ALsizei BytesAlloc;
enum UserFmtChannels OriginalChannels;
enum UserFmtType OriginalType;
ALsizei OriginalSize;
ALsizei OriginalAlign;
enum UserFmtType OriginalType;
ALsizei OriginalSize;
ALsizei OriginalAlign;
ALsizei LoopStart;
ALsizei LoopEnd;

5
OpenAL32/Include/sample_cvt.h
View File

@ -7,6 +7,9 @@
extern const ALshort muLawDecompressionTable[256];
extern const ALshort aLawDecompressionTable[256];
void ConvertData(ALvoid *dst, enum UserFmtType dstType, const ALvoid *src, enum UserFmtType srcType, ALsizei numchans, ALsizei len, ALsizei align);
void Convert_ALshort_ALima4(ALshort *dst, const ALubyte *src, ALsizei numchans, ALsizei len,
ALsizei align);
void Convert_ALshort_ALmsadpcm(ALshort *dst, const ALubyte *src, ALsizei numchans, ALsizei len,
ALsizei align);
#endif /* SAMPLE_CVT_H */

276
OpenAL32/alBuffer.c
View File

@ -45,9 +45,8 @@ extern inline struct ALbuffer *RemoveBuffer(ALCdevice *device, ALuint id);
extern inline ALsizei FrameSizeFromUserFmt(enum UserFmtChannels chans, enum UserFmtType type);
extern inline ALsizei FrameSizeFromFmt(enum FmtChannels chans, enum FmtType type);
static ALenum LoadData(ALbuffer *buffer, ALuint freq, ALenum NewFormat, ALsizei frames, enum UserFmtChannels SrcChannels, enum UserFmtType SrcType, const ALvoid *data, ALsizei align, ALbitfieldSOFT access, ALboolean storesrc);
static ALenum LoadData(ALbuffer *buffer, ALuint freq, ALsizei frames, enum UserFmtChannels SrcChannels, enum UserFmtType SrcType, const ALvoid *data, ALsizei align, ALbitfieldSOFT access);
static ALboolean DecomposeUserFormat(ALenum format, enum UserFmtChannels *chans, enum UserFmtType *type);
static ALboolean DecomposeFormat(ALenum format, enum FmtChannels *chans, enum FmtType *type);
static ALsizei SanitizeAlignment(enum UserFmtType type, ALsizei align);
@ -148,7 +147,6 @@ AL_API ALvoid AL_APIENTRY alBufferData(ALuint buffer, ALenum format, const ALvoi
ALCdevice *device;
ALCcontext *context;
ALbuffer *albuf;
ALenum newformat = AL_NONE;
ALsizei framesize;
ALsizei align;
ALenum err;
@ -180,59 +178,30 @@ AL_API ALvoid AL_APIENTRY alBufferData(ALuint buffer, ALenum format, const ALvoi
if((size%framesize) != 0)
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
err = LoadData(albuf, freq, format&FORMAT_MASK, size/framesize*align,
srcchannels, srctype, data, align, format&ACCESS_FLAGS,
AL_TRUE);
err = LoadData(albuf, freq, size/framesize*align, srcchannels, srctype,
data, align, format&ACCESS_FLAGS);
if(err != AL_NO_ERROR)
SET_ERROR_AND_GOTO(context, err, done);
break;
case UserFmtIMA4:
framesize = (align-1)/2 + 4;
framesize *= ChannelsFromUserFmt(srcchannels);
framesize = ((align-1)/2 + 4) * ChannelsFromUserFmt(srcchannels);
if((size%framesize) != 0)
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
switch(srcchannels)
{
case UserFmtMono: newformat = AL_FORMAT_MONO16; break;
case UserFmtStereo: newformat = AL_FORMAT_STEREO16; break;
case UserFmtRear: newformat = AL_FORMAT_REAR16; break;
case UserFmtQuad: newformat = AL_FORMAT_QUAD16; break;
case UserFmtX51: newformat = AL_FORMAT_51CHN16; break;
case UserFmtX61: newformat = AL_FORMAT_61CHN16; break;
case UserFmtX71: newformat = AL_FORMAT_71CHN16; break;
case UserFmtBFormat2D: newformat = AL_FORMAT_BFORMAT2D_16; break;
case UserFmtBFormat3D: newformat = AL_FORMAT_BFORMAT3D_16; break;
}
err = LoadData(albuf, freq, newformat, size/framesize*align,
srcchannels, srctype, data, align, format&ACCESS_FLAGS,
AL_TRUE);
err = LoadData(albuf, freq, size/framesize*align, srcchannels, srctype,
data, align, format&ACCESS_FLAGS);
if(err != AL_NO_ERROR)
SET_ERROR_AND_GOTO(context, err, done);
break;
case UserFmtMSADPCM:
framesize = (align-2)/2 + 7;
framesize *= ChannelsFromUserFmt(srcchannels);
framesize = ((align-2)/2 + 7) * ChannelsFromUserFmt(srcchannels);
if((size%framesize) != 0)
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
switch(srcchannels)
{
case UserFmtMono: newformat = AL_FORMAT_MONO16; break;
case UserFmtStereo: newformat = AL_FORMAT_STEREO16; break;
case UserFmtRear: newformat = AL_FORMAT_REAR16; break;
case UserFmtQuad: newformat = AL_FORMAT_QUAD16; break;
case UserFmtX51: newformat = AL_FORMAT_51CHN16; break;
case UserFmtX61: newformat = AL_FORMAT_61CHN16; break;
case UserFmtX71: newformat = AL_FORMAT_71CHN16; break;
case UserFmtBFormat2D: newformat = AL_FORMAT_BFORMAT2D_16; break;
case UserFmtBFormat3D: newformat = AL_FORMAT_BFORMAT3D_16; break;
}
err = LoadData(albuf, freq, newformat, size/framesize*align,
srcchannels, srctype, data, align, format&ACCESS_FLAGS,
AL_TRUE);
err = LoadData(albuf, freq, size/framesize*align, srcchannels, srctype,
data, align, format&ACCESS_FLAGS);
if(err != AL_NO_ERROR)
SET_ERROR_AND_GOTO(context, err, done);
break;
@ -319,9 +288,10 @@ AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer, ALenum format, cons
ALCcontext *context;
ALbuffer *albuf;
ALsizei byte_align;
ALsizei channels;
ALsizei bytes;
ALsizei frame_size;
ALsizei num_chans;
ALsizei align;
void *dst;
context = GetContextRef();
if(!context) return;
@ -342,7 +312,7 @@ AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer, ALenum format, cons
WriteUnlock(&albuf->lock);
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
}
if(srcchannels != albuf->OriginalChannels || srctype != albuf->OriginalType)
if((long)srcchannels != (long)albuf->FmtChannels || srctype != albuf->OriginalType)
{
WriteUnlock(&albuf->lock);
SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
@ -361,18 +331,17 @@ AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer, ALenum format, cons
if(albuf->OriginalType == UserFmtIMA4)
{
byte_align = (albuf->OriginalAlign-1)/2 + 4;
byte_align *= ChannelsFromUserFmt(albuf->OriginalChannels);
byte_align *= ChannelsFromFmt(albuf->FmtChannels);
}
else if(albuf->OriginalType == UserFmtMSADPCM)
{
byte_align = (albuf->OriginalAlign-2)/2 + 7;
byte_align *= ChannelsFromUserFmt(albuf->OriginalChannels);
byte_align *= ChannelsFromFmt(albuf->FmtChannels);
}
else
{
byte_align = albuf->OriginalAlign;
byte_align *= FrameSizeFromUserFmt(albuf->OriginalChannels,
albuf->OriginalType);
byte_align *= FrameSizeFromFmt(albuf->FmtChannels, albuf->FmtType);
}
if(offset > albuf->OriginalSize || length > albuf->OriginalSize-offset ||
@ -382,14 +351,22 @@ AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer, ALenum format, cons
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
}
channels = ChannelsFromFmt(albuf->FmtChannels);
bytes = BytesFromFmt(albuf->FmtType);
num_chans = ChannelsFromFmt(albuf->FmtChannels);
frame_size = num_chans * BytesFromFmt(albuf->FmtType);
/* offset -> byte offset, length -> sample count */
offset = offset/byte_align * channels*bytes;
offset = offset/byte_align * frame_size;
length = length/byte_align * albuf->OriginalAlign;
ConvertData((char*)albuf->data+offset, (enum UserFmtType)albuf->FmtType,
data, srctype, channels, length, align);
dst = (ALbyte*)albuf->data + offset;
if(srctype == UserFmtIMA4 && albuf->FmtType == FmtShort)
Convert_ALshort_ALima4(dst, data, num_chans, length, align);
else if(srctype == UserFmtMSADPCM && albuf->FmtType == FmtShort)
Convert_ALshort_ALmsadpcm(dst, data, num_chans, length, align);
else
{
assert((long)srctype == (long)albuf->FmtType);
memcpy(dst, data, length*frame_size);
}
WriteUnlock(&albuf->lock);
done:
@ -668,15 +645,6 @@ AL_API ALvoid AL_APIENTRY alGetBufferf(ALuint buffer, ALenum param, ALfloat *val
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
switch(param)
{
case AL_SEC_LENGTH_SOFT:
ReadLock(&albuf->lock);
if(albuf->SampleLen != 0)
*value = albuf->SampleLen / (ALfloat)albuf->Frequency;
else
*value = 0.0f;
ReadUnlock(&albuf->lock);
break;
default:
SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
}
@ -785,18 +753,6 @@ AL_API ALvoid AL_APIENTRY alGetBufferi(ALuint buffer, ALenum param, ALint *value
ReadUnlock(&albuf->lock);
break;
case AL_INTERNAL_FORMAT_SOFT:
*value = albuf->Format;
break;
case AL_BYTE_LENGTH_SOFT:
*value = albuf->OriginalSize;
break;
case AL_SAMPLE_LENGTH_SOFT:
*value = albuf->SampleLen;
break;
case AL_UNPACK_BLOCK_ALIGNMENT_SOFT:
*value = ATOMIC_LOAD_SEQ(&albuf->UnpackAlign);
break;
@ -899,32 +855,54 @@ done:
* Currently, the new format must have the same channel configuration as the
* original format.
*/
static ALenum LoadData(ALbuffer *ALBuf, ALuint freq, ALenum NewFormat, ALsizei frames, enum UserFmtChannels SrcChannels, enum UserFmtType SrcType, const ALvoid *data, ALsizei align, ALbitfieldSOFT access, ALboolean storesrc)
static ALenum LoadData(ALbuffer *ALBuf, ALuint freq, ALsizei frames, enum UserFmtChannels SrcChannels, enum UserFmtType SrcType, const ALvoid *data, ALsizei align, ALbitfieldSOFT access)
{
enum FmtChannels DstChannels = FmtMono;
enum FmtType DstType = FmtUByte;
ALuint NewChannels, NewBytes;
ALuint64 newsize;
ALsizei NumChannels, FrameSize;
ALsizei newsize;
if(DecomposeFormat(NewFormat, &DstChannels, &DstType) == AL_FALSE)
return AL_INVALID_ENUM;
/* Currently no channels need to be converted. */
switch(SrcChannels)
{
case UserFmtMono: DstChannels = FmtMono; break;
case UserFmtStereo: DstChannels = FmtStereo; break;
case UserFmtRear: DstChannels = FmtRear; break;
case UserFmtQuad: DstChannels = FmtQuad; break;
case UserFmtX51: DstChannels = FmtX51; break;
case UserFmtX61: DstChannels = FmtX61; break;
case UserFmtX71: DstChannels = FmtX71; break;
case UserFmtBFormat2D: DstChannels = FmtBFormat2D; break;
case UserFmtBFormat3D: DstChannels = FmtBFormat3D; break;
}
if((long)SrcChannels != (long)DstChannels)
return AL_INVALID_ENUM;
/* IMA4 and MSADPCM convert to 16-bit short. */
switch(SrcType)
{
case UserFmtUByte: DstType = FmtUByte; break;
case UserFmtShort: DstType = FmtShort; break;
case UserFmtFloat: DstType = FmtFloat; break;
case UserFmtDouble: DstType = FmtDouble; break;
case UserFmtAlaw: DstType = FmtAlaw; break;
case UserFmtMulaw: DstType = FmtMulaw; break;
case UserFmtIMA4: DstType = FmtShort; break;
case UserFmtMSADPCM: DstType = FmtShort; break;
}
if(access != 0)
{
if(!storesrc || (long)SrcType != (long)DstType)
if((long)SrcType != (long)DstType)
return AL_INVALID_VALUE;
}
NewChannels = ChannelsFromFmt(DstChannels);
NewBytes = BytesFromFmt(DstType);
NumChannels = ChannelsFromFmt(DstChannels);
FrameSize = NumChannels * BytesFromFmt(DstType);
newsize = frames;
newsize *= NewBytes;
newsize *= NewChannels;
if(newsize > INT_MAX)
if(frames > INT_MAX/FrameSize)
return AL_OUT_OF_MEMORY;
newsize = frames*FrameSize;
WriteLock(&ALBuf->lock);
if(ReadRef(&ALBuf->ref) != 0 || ALBuf->MappedAccess != 0)
@ -939,7 +917,8 @@ static ALenum LoadData(ALbuffer *ALBuf, ALuint freq, ALenum NewFormat, ALsizei f
* usage, and reporting the real size could cause problems for apps that
* use AL_SIZE to try to get the buffer's play length.
*/
newsize = (newsize+15) & ~0xf;
if(newsize <= INT_MAX-15)
newsize = (newsize+15) & ~0xf;
if(newsize != ALBuf->BytesAlloc)
{
void *temp = al_calloc(16, (size_t)newsize);
@ -950,46 +929,42 @@ static ALenum LoadData(ALbuffer *ALBuf, ALuint freq, ALenum NewFormat, ALsizei f
}
al_free(ALBuf->data);
ALBuf->data = temp;
ALBuf->BytesAlloc = (ALuint)newsize;
ALBuf->BytesAlloc = newsize;
}
if(data != NULL)
ConvertData(ALBuf->data, (enum UserFmtType)DstType, data, SrcType, NewChannels, frames, align);
if(storesrc)
ALBuf->OriginalType = SrcType;
if(SrcType == UserFmtIMA4)
{
ALBuf->OriginalChannels = SrcChannels;
ALBuf->OriginalType = SrcType;
if(SrcType == UserFmtIMA4)
{
ALsizei byte_align = ((align-1)/2 + 4) * ChannelsFromUserFmt(SrcChannels);
ALBuf->OriginalSize = frames / align * byte_align;
ALBuf->OriginalAlign = align;
}
else if(SrcType == UserFmtMSADPCM)
{
ALsizei byte_align = ((align-2)/2 + 7) * ChannelsFromUserFmt(SrcChannels);
ALBuf->OriginalSize = frames / align * byte_align;
ALBuf->OriginalAlign = align;
}
else
{
ALBuf->OriginalSize = frames * FrameSizeFromUserFmt(SrcChannels, SrcType);
ALBuf->OriginalAlign = 1;
}
ALsizei byte_align = ((align-1)/2 + 4) * NumChannels;
ALBuf->OriginalSize = frames / align * byte_align;
ALBuf->OriginalAlign = align;
assert(DstType == FmtShort);
if(data != NULL)
Convert_ALshort_ALima4(ALBuf->data, data, NumChannels, frames, align);
}
else if(SrcType == UserFmtMSADPCM)
{
ALsizei byte_align = ((align-2)/2 + 7) * NumChannels;
ALBuf->OriginalSize = frames / align * byte_align;
ALBuf->OriginalAlign = align;
assert(DstType == FmtShort);
if(data != NULL)
Convert_ALshort_ALmsadpcm(ALBuf->data, data, NumChannels, frames, align);
}
else
{
ALBuf->OriginalChannels = (enum UserFmtChannels)DstChannels;
ALBuf->OriginalType = (enum UserFmtType)DstType;
ALBuf->OriginalSize = frames * NewBytes * NewChannels;
ALBuf->OriginalAlign = 1;
ALBuf->OriginalSize = frames * FrameSize;
ALBuf->OriginalAlign = 1;
if(data != NULL)
{
assert((long)SrcType == (long)DstType);
memcpy(ALBuf->data, data, frames*FrameSize);
}
}
ALBuf->Frequency = freq;
ALBuf->FmtChannels = DstChannels;
ALBuf->FmtType = DstType;
ALBuf->Format = NewFormat;
ALBuf->Access = access;
ALBuf->SampleLen = frames;
@ -1140,77 +1115,6 @@ ALsizei ChannelsFromFmt(enum FmtChannels chans)
}
return 0;
}
static ALboolean DecomposeFormat(ALenum format, enum FmtChannels *chans, enum FmtType *type)
{
static const struct {
ALenum format;
enum FmtChannels channels;
enum FmtType type;
} list[] = {
{ AL_FORMAT_MONO8, FmtMono, FmtUByte },
{ AL_FORMAT_MONO16, FmtMono, FmtShort },
{ AL_FORMAT_MONO_FLOAT32, FmtMono, FmtFloat },
{ AL_FORMAT_MONO_MULAW, FmtMono, FmtMulaw },
{ AL_FORMAT_MONO_ALAW_EXT, FmtMono, FmtAlaw },
{ AL_FORMAT_STEREO8, FmtStereo, FmtUByte },
{ AL_FORMAT_STEREO16, FmtStereo, FmtShort },
{ AL_FORMAT_STEREO_FLOAT32, FmtStereo, FmtFloat },
{ AL_FORMAT_STEREO_MULAW, FmtStereo, FmtMulaw },
{ AL_FORMAT_STEREO_ALAW_EXT, FmtStereo, FmtAlaw },
{ AL_FORMAT_REAR8, FmtRear, FmtUByte },
{ AL_FORMAT_REAR16, FmtRear, FmtShort },
{ AL_FORMAT_REAR32, FmtRear, FmtFloat },
{ AL_FORMAT_REAR_MULAW, FmtRear, FmtMulaw },
{ AL_FORMAT_QUAD8_LOKI, FmtQuad, FmtUByte },
{ AL_FORMAT_QUAD16_LOKI, FmtQuad, FmtShort },
{ AL_FORMAT_QUAD8, FmtQuad, FmtUByte },
{ AL_FORMAT_QUAD16, FmtQuad, FmtShort },
{ AL_FORMAT_QUAD32, FmtQuad, FmtFloat },
{ AL_FORMAT_QUAD_MULAW, FmtQuad, FmtMulaw },
{ AL_FORMAT_51CHN8, FmtX51, FmtUByte },
{ AL_FORMAT_51CHN16, FmtX51, FmtShort },
{ AL_FORMAT_51CHN32, FmtX51, FmtFloat },
{ AL_FORMAT_51CHN_MULAW, FmtX51, FmtMulaw },
{ AL_FORMAT_61CHN8, FmtX61, FmtUByte },
{ AL_FORMAT_61CHN16, FmtX61, FmtShort },
{ AL_FORMAT_61CHN32, FmtX61, FmtFloat },
{ AL_FORMAT_61CHN_MULAW, FmtX61, FmtMulaw },
{ AL_FORMAT_71CHN8, FmtX71, FmtUByte },
{ AL_FORMAT_71CHN16, FmtX71, FmtShort },
{ AL_FORMAT_71CHN32, FmtX71, FmtFloat },
{ AL_FORMAT_71CHN_MULAW, FmtX71, FmtMulaw },
{ AL_FORMAT_BFORMAT2D_8, FmtBFormat2D, FmtUByte },
{ AL_FORMAT_BFORMAT2D_16, FmtBFormat2D, FmtShort },
{ AL_FORMAT_BFORMAT2D_FLOAT32, FmtBFormat2D, FmtFloat },
{ AL_FORMAT_BFORMAT2D_MULAW, FmtBFormat2D, FmtMulaw },
{ AL_FORMAT_BFORMAT3D_8, FmtBFormat3D, FmtUByte },
{ AL_FORMAT_BFORMAT3D_16, FmtBFormat3D, FmtShort },
{ AL_FORMAT_BFORMAT3D_FLOAT32, FmtBFormat3D, FmtFloat },
{ AL_FORMAT_BFORMAT3D_MULAW, FmtBFormat3D, FmtMulaw },
};
size_t i;
for(i = 0;i < COUNTOF(list);i++)
{
if(list[i].format == format)
{
*chans = list[i].channels;
*type = list[i].type;
return AL_TRUE;
}
}
return AL_FALSE;
}
static ALsizei SanitizeAlignment(enum UserFmtType type, ALsizei align)
{

13
OpenAL32/alSource.c
View File

@ -2897,7 +2897,7 @@ AL_API ALvoid AL_APIENTRY alSourceQueueBuffers(ALuint src, ALsizei nb, const ALu
if(BufferFmt == NULL)
BufferFmt = buffer;
else if(BufferFmt->Frequency != buffer->Frequency ||
BufferFmt->OriginalChannels != buffer->OriginalChannels ||
BufferFmt->FmtChannels != buffer->FmtChannels ||
BufferFmt->OriginalType != buffer->OriginalType)
{
WriteUnlock(&source->queue_lock);
@ -3493,8 +3493,8 @@ static ALdouble GetSourceOffset(ALsource *Source, ALenum name, ALCcontext *conte
}
else
{
ALuint FrameSize = FrameSizeFromUserFmt(BufferFmt->OriginalChannels,
BufferFmt->OriginalType);
ALuint FrameSize = FrameSizeFromFmt(BufferFmt->FmtChannels,
BufferFmt->FmtType);
offset = (ALdouble)(readPos * FrameSize);
}
break;
@ -3593,18 +3593,17 @@ static ALboolean GetSampleOffset(ALsource *Source, ALuint *offset, ALsizei *frac
if(BufferFmt->OriginalType == UserFmtIMA4)
{
ALsizei align = (BufferFmt->OriginalAlign-1)/2 + 4;
*offset /= align * ChannelsFromUserFmt(BufferFmt->OriginalChannels);
*offset /= align * ChannelsFromFmt(BufferFmt->FmtChannels);
*offset *= BufferFmt->OriginalAlign;
}
else if(BufferFmt->OriginalType == UserFmtMSADPCM)
{
ALsizei align = (BufferFmt->OriginalAlign-2)/2 + 7;
*offset /= align * ChannelsFromUserFmt(BufferFmt->OriginalChannels);
*offset /= align * ChannelsFromFmt(BufferFmt->FmtChannels);
*offset *= BufferFmt->OriginalAlign;
}
else
*offset /= FrameSizeFromUserFmt(BufferFmt->OriginalChannels,
BufferFmt->OriginalType);
*offset /= FrameSizeFromFmt(BufferFmt->FmtChannels, BufferFmt->FmtType);
*frac = 0;
break;

633
OpenAL32/sample_cvt.c
View File

@ -3,25 +3,11 @@
#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"
#ifdef HAVE_C99_VLA
#define DECL_VLA(T, _name, _size) T _name[(_size)]
#else
#define DECL_VLA(T, _name, _size) T *_name = alloca((_size) * sizeof(T))
#endif
/* IMA ADPCM Stepsize table */
static const int IMAStep_size[89] = {
7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19,
@ -103,28 +89,6 @@ 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 */
@ -163,80 +127,8 @@ 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;
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)
{
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)
static void DecodeIMA4Block(ALshort *dst, const ALubyte *src, ALint numchans, ALsizei align)
{
ALint sample[MAX_INPUT_CHANNELS], index[MAX_INPUT_CHANNELS];
ALuint code[MAX_INPUT_CHANNELS];
@ -285,73 +177,7 @@ static void DecodeIMA4Block(ALshort *dst, const ALima4 *src, ALint numchans, ALs
}
}
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;
}
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);
if(!(k&1)) *dst = nibble;
else *(dst++) |= nibble<<4;
}
}
}
}
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];
@ -417,217 +243,9 @@ static void DecodeMSADPCMBlock(ALshort *dst, const ALmsadpcm *src, ALint numchan
}
}
/* 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++;
}
}
}
}
/* Define same-type pass-through sample conversion functions (excludes ADPCM,
* which are block-based). */
#define DECL_TEMPLATE(T) \
static inline T Conv_##T##_##T(T val) { return val; }
DECL_TEMPLATE(ALubyte);
DECL_TEMPLATE(ALshort);
DECL_TEMPLATE(ALalaw);
DECL_TEMPLATE(ALmulaw);
/* Slightly special handling for floats and doubles (converts NaN to 0, and
* allows float<->double pass-through).
*/
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 ALdouble Conv_ALdouble_ALfloat(ALfloat val)
{ return (val==val) ? (ALdouble)val : 0.0; }
static inline ALdouble Conv_ALdouble_ALdouble(ALdouble val)
{ return (val==val) ? val : 0.0; }
#undef DECL_TEMPLATE
/* Define int-type to int-type functions */
static inline ALubyte Conv_ALubyte_ALshort(ALshort val) { return (val>>8) + 128; }
static inline ALshort Conv_ALshort_ALubyte(ALubyte val) { return (val-128) << 8; }
/* Define int-type to fp functions */
static inline ALfloat Conv_ALfloat_ALubyte(ALubyte val) { return (val-128) * (1.0f/128.0f); }
static inline ALdouble Conv_ALdouble_ALubyte(ALubyte val) { return (val-128) * (1.0/128.0); }
static inline ALfloat Conv_ALfloat_ALshort(ALshort val) { return val * (1.0f/32768.0f); }
static inline ALdouble Conv_ALdouble_ALshort(ALshort val) { return val * (1.0/32768.0); }
/* Define fp to int-type functions */
static inline ALubyte Conv_ALubyte_ALfloat(ALfloat val)
{
val *= 128.0f;
if(val >= 127.0f) return 255;
if(val <= -128.0f) return 0;
return (ALbyte)val + 128;
}
static inline ALubyte Conv_ALubyte_ALdouble(ALdouble val) { return Conv_ALubyte_ALfloat(val); }
static inline ALshort Conv_ALshort_ALfloat(ALfloat val)
{
val *= 32768.0f;
if(val >= 32767.0f) return 32767;
if(val <= -32768.0f) return -32768;
return (ALshort)val;
}
static inline ALshort Conv_ALshort_ALdouble(ALdouble val) { return Conv_ALshort_ALfloat(val); }
/* Define muLaw and aLaw functions (goes through short functions). */
#define DECL_TEMPLATE(T) \
static inline ALmulaw Conv_ALmulaw_##T(T val) \
{ return EncodeMuLaw(Conv_ALshort_##T(val)); } \
static inline T Conv_##T##_ALmulaw(ALmulaw val) \
{ return Conv_##T##_ALshort(DecodeMuLaw(val)); } \
\
static inline ALalaw Conv_ALalaw_##T(T val) \
{ return EncodeALaw(Conv_ALshort_##T(val)); } \
static inline T Conv_##T##_ALalaw(ALalaw val) \
{ return Conv_##T##_ALshort(DecodeALaw(val)); }
DECL_TEMPLATE(ALubyte)
DECL_TEMPLATE(ALshort)
DECL_TEMPLATE(ALfloat)
DECL_TEMPLATE(ALdouble)
#undef DECL_TEMPLATE
/* Define muLaw <-> aLaw functions. */
static inline ALalaw Conv_ALalaw_ALmulaw(ALmulaw val)
{ return EncodeALaw(DecodeMuLaw(val)); }
static inline ALmulaw Conv_ALmulaw_ALalaw(ALalaw val)
{ return EncodeMuLaw(DecodeALaw(val)); }
#define DECL_TEMPLATE(T1, T2) \
static void Convert_##T1##_##T2(T1 *dst, const T2 *src, ALsizei numchans, \
ALsizei len, ALsizei UNUSED(align)) \
{ \
ALsizei i; \
len *= numchans; \
for(i = 0;i < len;i++) \
*(dst++) = Conv_##T1##_##T2(*(src++)); \
}
#define DECL_TEMPLATE2(T) \
DECL_TEMPLATE(T, ALubyte) \
DECL_TEMPLATE(T, ALshort) \
DECL_TEMPLATE(T, ALfloat) \
DECL_TEMPLATE(T, ALdouble) \
DECL_TEMPLATE(T, ALmulaw) \
DECL_TEMPLATE(T, ALalaw)
DECL_TEMPLATE2(ALubyte)
DECL_TEMPLATE2(ALshort)
DECL_TEMPLATE2(ALfloat)
DECL_TEMPLATE2(ALdouble)
DECL_TEMPLATE2(ALmulaw)
DECL_TEMPLATE2(ALalaw)
#undef DECL_TEMPLATE2
#undef DECL_TEMPLATE
#define DECL_TEMPLATE(T) \
static void Convert_##T##_ALima4(T *dst, const ALima4 *src, ALsizei numchans, \
ALsizei len, ALsizei align) \
{ \
ALsizei byte_align = ((align-1)/2 + 4) * numchans; \
DECL_VLA(ALshort, tmp, align*numchans); \
ALsizei 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(ALubyte)
static void Convert_ALshort_ALima4(ALshort *dst, const ALima4 *src, ALsizei numchans,
ALsizei len, ALsizei align)
void Convert_ALshort_ALima4(ALshort *dst, const ALubyte *src, ALsizei numchans, ALsizei len,
ALsizei align)
{
ALsizei byte_align = ((align-1)/2 + 4) * numchans;
ALsizei i;
@ -640,88 +258,9 @@ static void Convert_ALshort_ALima4(ALshort *dst, const ALima4 *src, ALsizei numc
dst += align*numchans;
}
}
DECL_TEMPLATE(ALfloat)
DECL_TEMPLATE(ALdouble)
DECL_TEMPLATE(ALmulaw)
DECL_TEMPLATE(ALalaw)
#undef DECL_TEMPLATE
#define DECL_TEMPLATE(T) \
static void Convert_ALima4_##T(ALima4 *dst, const T *src, ALsizei numchans, \
ALsizei len, ALsizei 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); \
ALsizei 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(ALubyte)
static void Convert_ALima4_ALshort(ALima4 *dst, const ALshort *src,
ALsizei numchans, ALsizei len, ALsizei 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;
ALsizei 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(ALfloat)
DECL_TEMPLATE(ALdouble)
DECL_TEMPLATE(ALmulaw)
DECL_TEMPLATE(ALalaw)
#undef DECL_TEMPLATE
#define DECL_TEMPLATE(T) \
static void Convert_##T##_ALmsadpcm(T *dst, const ALmsadpcm *src, \
ALsizei numchans, ALsizei len, \
ALsizei align) \
{ \
ALsizei byte_align = ((align-2)/2 + 7) * numchans; \
DECL_VLA(ALshort, tmp, align*numchans); \
ALsizei 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(ALubyte)
static void Convert_ALshort_ALmsadpcm(ALshort *dst, const ALmsadpcm *src,
ALsizei numchans, ALsizei len,
ALsizei align)
void Convert_ALshort_ALmsadpcm(ALshort *dst, const ALubyte *src, ALsizei numchans, ALsizei len,
ALsizei align)
{
ALsizei byte_align = ((align-2)/2 + 7) * numchans;
ALsizei i;
@ -734,163 +273,3 @@ static void Convert_ALshort_ALmsadpcm(ALshort *dst, const ALmsadpcm *src,
dst += align*numchans;
}
}
DECL_TEMPLATE(ALfloat)
DECL_TEMPLATE(ALdouble)
DECL_TEMPLATE(ALmulaw)
DECL_TEMPLATE(ALalaw)
#undef DECL_TEMPLATE
#define DECL_TEMPLATE(T) \
static void Convert_ALmsadpcm_##T(ALmsadpcm *dst, const T *src, \
ALsizei numchans, ALsizei len, \
ALsizei 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); \
ALsizei 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(ALubyte)
static void Convert_ALmsadpcm_ALshort(ALmsadpcm *dst, const ALshort *src,
ALsizei numchans, ALsizei len, ALsizei align)
{
ALint sample[MAX_INPUT_CHANNELS] = {0,0,0,0,0,0,0,0};
ALsizei byte_align = ((align-2)/2 + 7) * numchans;
ALsizei 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(ALfloat)
DECL_TEMPLATE(ALdouble)
DECL_TEMPLATE(ALmulaw)
DECL_TEMPLATE(ALalaw)
#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),
ALsizei UNUSED(numchans), ALsizei UNUSED(len),
ALsizei UNUSED(align))
{
ERR("Unexpected IMA4-to-IMA4 conversion!\n");
}
static void Convert_ALmsadpcm_ALmsadpcm(ALmsadpcm* UNUSED(dst), const ALmsadpcm* UNUSED(src),
ALsizei UNUSED(numchans), ALsizei UNUSED(len),
ALsizei UNUSED(align))
{
ERR("Unexpected MSADPCM-to-MSADPCM conversion!\n");
}
static void Convert_ALmsadpcm_ALima4(ALmsadpcm* UNUSED(dst), const ALima4* UNUSED(src),
ALsizei UNUSED(numchans), ALsizei UNUSED(len),
ALsizei UNUSED(align))
{
ERR("Unexpected IMA4-to-MSADPCM conversion!\n");
}
static void Convert_ALima4_ALmsadpcm(ALima4* UNUSED(dst), const ALmsadpcm* UNUSED(src),
ALsizei UNUSED(numchans), ALsizei UNUSED(len),
ALsizei 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 UserFmtUByte: \
Convert_##T##_ALubyte(dst, src, numchans, len, align); \
break; \
case UserFmtShort: \
Convert_##T##_ALshort(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; \
} \
}
DECL_TEMPLATE(ALubyte)
DECL_TEMPLATE(ALshort)
DECL_TEMPLATE(ALfloat)
DECL_TEMPLATE(ALdouble)
DECL_TEMPLATE(ALmulaw)
DECL_TEMPLATE(ALalaw)
DECL_TEMPLATE(ALima4)
DECL_TEMPLATE(ALmsadpcm)
#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 UserFmtUByte:
Convert_ALubyte(dst, src, srcType, numchans, len, align);
break;
case UserFmtShort:
Convert_ALshort(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;
}
}