From b615c7d0a2928ca07a3aafdd4013be2e4b951135 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Sun, 18 Sep 2011 19:06:19 -0700 Subject: Use arrays instead of large switches to decompose formats --- OpenAL32/Include/alBuffer.h | 3 - OpenAL32/alBuffer.c | 325 +++++++++++++++----------------------------- 2 files changed, 106 insertions(+), 222 deletions(-) (limited to 'OpenAL32') diff --git a/OpenAL32/Include/alBuffer.h b/OpenAL32/Include/alBuffer.h index 6ab25615..9393a6e6 100644 --- a/OpenAL32/Include/alBuffer.h +++ b/OpenAL32/Include/alBuffer.h @@ -32,8 +32,6 @@ enum UserFmtChannels { UserFmtX71 = AL_7POINT1 /* (WFX order) */ }; -ALboolean DecomposeUserFormat(ALenum format, enum UserFmtChannels *chans, - enum UserFmtType *type); ALuint BytesFromUserFmt(enum UserFmtType type); ALuint ChannelsFromUserFmt(enum UserFmtChannels chans); static __inline ALuint FrameSizeFromUserFmt(enum UserFmtChannels chans, @@ -59,7 +57,6 @@ enum FmtChannels { FmtX71 = UserFmtX71, }; -ALboolean DecomposeFormat(ALenum format, enum FmtChannels *chans, enum FmtType *type); ALuint BytesFromFmt(enum FmtType type); ALuint ChannelsFromFmt(enum FmtChannels chans); static __inline ALuint FrameSizeFromFmt(enum FmtChannels chans, enum FmtType type) diff --git a/OpenAL32/alBuffer.c b/OpenAL32/alBuffer.c index 6347e9d8..dc7baecb 100644 --- a/OpenAL32/alBuffer.c +++ b/OpenAL32/alBuffer.c @@ -37,6 +37,8 @@ static ALenum LoadData(ALbuffer *ALBuf, ALuint freq, ALenum NewFormat, ALsizei f static void ConvertData(ALvoid *dst, enum UserFmtType dstType, const ALvoid *src, enum UserFmtType srcType, ALsizei numchans, ALsizei len); static ALboolean IsValidType(ALenum type); static ALboolean IsValidChannels(ALenum channels); +static ALboolean DecomposeUserFormat(ALenum format, enum UserFmtChannels *chans, enum UserFmtType *type); +static ALboolean DecomposeFormat(ALenum format, enum FmtChannels *chans, enum FmtType *type); #define LookupBuffer(m, k) ((ALbuffer*)LookupUIntMapKey(&(m), (k))) #define RemoveBuffer(m, k) ((ALbuffer*)PopUIntMapValue(&(m), (k))) @@ -1928,142 +1930,68 @@ ALuint ChannelsFromUserFmt(enum UserFmtChannels chans) } return 0; } -ALboolean DecomposeUserFormat(ALenum format, enum UserFmtChannels *chans, - enum UserFmtType *type) +static ALboolean DecomposeUserFormat(ALenum format, enum UserFmtChannels *chans, + enum UserFmtType *type) { - switch(format) + static const struct { + ALenum format; + enum UserFmtChannels channels; + enum UserFmtType type; + } list[] = { + { AL_FORMAT_MONO8, UserFmtMono, UserFmtUByte }, + { AL_FORMAT_MONO16, UserFmtMono, UserFmtShort }, + { AL_FORMAT_MONO_FLOAT32, UserFmtMono, UserFmtFloat }, + { AL_FORMAT_MONO_DOUBLE_EXT, UserFmtMono, UserFmtDouble }, + { AL_FORMAT_MONO_IMA4, UserFmtMono, UserFmtIMA4 }, + { AL_FORMAT_MONO_MULAW, UserFmtMono, UserFmtMulaw }, + + { AL_FORMAT_STEREO8, UserFmtStereo, UserFmtUByte }, + { AL_FORMAT_STEREO16, UserFmtStereo, UserFmtShort }, + { AL_FORMAT_STEREO_FLOAT32, UserFmtStereo, UserFmtFloat }, + { AL_FORMAT_STEREO_DOUBLE_EXT, UserFmtStereo, UserFmtDouble }, + { AL_FORMAT_STEREO_IMA4, UserFmtStereo, UserFmtIMA4 }, + { AL_FORMAT_STEREO_MULAW, UserFmtStereo, UserFmtMulaw }, + + { AL_FORMAT_REAR8, UserFmtRear, UserFmtUByte }, + { AL_FORMAT_REAR16, UserFmtRear, UserFmtShort }, + { AL_FORMAT_REAR32, UserFmtRear, UserFmtFloat }, + { AL_FORMAT_REAR_MULAW, UserFmtRear, UserFmtMulaw }, + + { AL_FORMAT_QUAD8_LOKI, UserFmtQuad, UserFmtUByte }, + { AL_FORMAT_QUAD16_LOKI, UserFmtQuad, UserFmtShort }, + + { AL_FORMAT_QUAD8, UserFmtQuad, UserFmtUByte }, + { AL_FORMAT_QUAD16, UserFmtQuad, UserFmtShort }, + { AL_FORMAT_QUAD32, UserFmtQuad, UserFmtFloat }, + { AL_FORMAT_QUAD_MULAW, UserFmtQuad, UserFmtMulaw }, + + { AL_FORMAT_51CHN8, UserFmtX51, UserFmtUByte }, + { AL_FORMAT_51CHN16, UserFmtX51, UserFmtShort }, + { AL_FORMAT_51CHN32, UserFmtX51, UserFmtFloat }, + { AL_FORMAT_51CHN_MULAW, UserFmtX51, UserFmtMulaw }, + + { AL_FORMAT_61CHN8, UserFmtX61, UserFmtUByte }, + { AL_FORMAT_61CHN16, UserFmtX61, UserFmtShort }, + { AL_FORMAT_61CHN32, UserFmtX61, UserFmtFloat }, + { AL_FORMAT_61CHN_MULAW, UserFmtX61, UserFmtMulaw }, + + { AL_FORMAT_71CHN8, UserFmtX71, UserFmtUByte }, + { AL_FORMAT_71CHN16, UserFmtX71, UserFmtShort }, + { AL_FORMAT_71CHN32, UserFmtX71, UserFmtFloat }, + { AL_FORMAT_71CHN_MULAW, UserFmtX71, UserFmtMulaw }, + }; + ALuint i; + + for(i = 0;i < sizeof(list)/sizeof(list[0]);i++) { - case AL_FORMAT_MONO8: - *chans = UserFmtMono; - *type = UserFmtUByte; - return AL_TRUE; - case AL_FORMAT_MONO16: - *chans = UserFmtMono; - *type = UserFmtShort; - return AL_TRUE; - case AL_FORMAT_MONO_FLOAT32: - *chans = UserFmtMono; - *type = UserFmtFloat; - return AL_TRUE; - case AL_FORMAT_MONO_DOUBLE_EXT: - *chans = UserFmtMono; - *type = UserFmtDouble; - return AL_TRUE; - case AL_FORMAT_MONO_IMA4: - *chans = UserFmtMono; - *type = UserFmtIMA4; - return AL_TRUE; - case AL_FORMAT_STEREO8: - *chans = UserFmtStereo; - *type = UserFmtUByte; - return AL_TRUE; - case AL_FORMAT_STEREO16: - *chans = UserFmtStereo; - *type = UserFmtShort; - return AL_TRUE; - case AL_FORMAT_STEREO_FLOAT32: - *chans = UserFmtStereo; - *type = UserFmtFloat; - return AL_TRUE; - case AL_FORMAT_STEREO_DOUBLE_EXT: - *chans = UserFmtStereo; - *type = UserFmtDouble; - return AL_TRUE; - case AL_FORMAT_STEREO_IMA4: - *chans = UserFmtStereo; - *type = UserFmtIMA4; - return AL_TRUE; - case AL_FORMAT_QUAD8_LOKI: - case AL_FORMAT_QUAD8: - *chans = UserFmtQuad; - *type = UserFmtUByte; - return AL_TRUE; - case AL_FORMAT_QUAD16_LOKI: - case AL_FORMAT_QUAD16: - *chans = UserFmtQuad; - *type = UserFmtShort; - return AL_TRUE; - case AL_FORMAT_QUAD32: - *chans = UserFmtQuad; - *type = UserFmtFloat; - return AL_TRUE; - case AL_FORMAT_REAR8: - *chans = UserFmtRear; - *type = UserFmtUByte; - return AL_TRUE; - case AL_FORMAT_REAR16: - *chans = UserFmtRear; - *type = UserFmtShort; - return AL_TRUE; - case AL_FORMAT_REAR32: - *chans = UserFmtRear; - *type = UserFmtFloat; - return AL_TRUE; - case AL_FORMAT_51CHN8: - *chans = UserFmtX51; - *type = UserFmtUByte; - return AL_TRUE; - case AL_FORMAT_51CHN16: - *chans = UserFmtX51; - *type = UserFmtShort; - return AL_TRUE; - case AL_FORMAT_51CHN32: - *chans = UserFmtX51; - *type = UserFmtFloat; - return AL_TRUE; - case AL_FORMAT_61CHN8: - *chans = UserFmtX61; - *type = UserFmtUByte; - return AL_TRUE; - case AL_FORMAT_61CHN16: - *chans = UserFmtX61; - *type = UserFmtShort; - return AL_TRUE; - case AL_FORMAT_61CHN32: - *chans = UserFmtX61; - *type = UserFmtFloat; - return AL_TRUE; - case AL_FORMAT_71CHN8: - *chans = UserFmtX71; - *type = UserFmtUByte; - return AL_TRUE; - case AL_FORMAT_71CHN16: - *chans = UserFmtX71; - *type = UserFmtShort; - return AL_TRUE; - case AL_FORMAT_71CHN32: - *chans = UserFmtX71; - *type = UserFmtFloat; - return AL_TRUE; - case AL_FORMAT_MONO_MULAW: - *chans = UserFmtMono; - *type = UserFmtMulaw; - return AL_TRUE; - case AL_FORMAT_STEREO_MULAW: - *chans = UserFmtStereo; - *type = UserFmtMulaw; - return AL_TRUE; - case AL_FORMAT_QUAD_MULAW: - *chans = UserFmtQuad; - *type = UserFmtMulaw; - return AL_TRUE; - case AL_FORMAT_REAR_MULAW: - *chans = UserFmtRear; - *type = UserFmtMulaw; - return AL_TRUE; - case AL_FORMAT_51CHN_MULAW: - *chans = UserFmtX51; - *type = UserFmtMulaw; - return AL_TRUE; - case AL_FORMAT_61CHN_MULAW: - *chans = UserFmtX61; - *type = UserFmtMulaw; - return AL_TRUE; - case AL_FORMAT_71CHN_MULAW: - *chans = UserFmtX71; - *type = UserFmtMulaw; + if(list[i].format == format) + { + *chans = list[i].channels; + *type = list[i].type; return AL_TRUE; + } } + return AL_FALSE; } @@ -2091,97 +2019,56 @@ ALuint ChannelsFromFmt(enum FmtChannels chans) } return 0; } -ALboolean DecomposeFormat(ALenum format, enum FmtChannels *chans, enum FmtType *type) +static ALboolean DecomposeFormat(ALenum format, enum FmtChannels *chans, enum FmtType *type) { - switch(format) + static const struct { + ALenum format; + enum FmtChannels channels; + enum FmtType type; + } list[] = { + { AL_MONO8, FmtMono, FmtByte }, + { AL_MONO16, FmtMono, FmtShort }, + { AL_MONO32F, FmtMono, FmtFloat }, + + { AL_STEREO8, FmtStereo, FmtByte }, + { AL_STEREO16, FmtStereo, FmtShort }, + { AL_STEREO32F, FmtStereo, FmtFloat }, + + { AL_REAR8, FmtRear, FmtByte }, + { AL_REAR16, FmtRear, FmtShort }, + { AL_REAR32F, FmtRear, FmtFloat }, + + { AL_FORMAT_QUAD8_LOKI, FmtQuad, FmtByte }, + { AL_FORMAT_QUAD16_LOKI, FmtQuad, FmtShort }, + + { AL_QUAD8, FmtQuad, FmtByte }, + { AL_QUAD16, FmtQuad, FmtShort }, + { AL_QUAD32F, FmtQuad, FmtFloat }, + + { AL_5POINT1_8, FmtX51, FmtByte }, + { AL_5POINT1_16, FmtX51, FmtShort }, + { AL_5POINT1_32F, FmtX51, FmtFloat }, + + { AL_6POINT1_8, FmtX61, FmtByte }, + { AL_6POINT1_16, FmtX61, FmtShort }, + { AL_6POINT1_32F, FmtX61, FmtFloat }, + + { AL_7POINT1_8, FmtX71, FmtByte }, + { AL_7POINT1_16, FmtX71, FmtShort }, + { AL_7POINT1_32F, FmtX71, FmtFloat }, + }; + ALuint i; + + for(i = 0;i < sizeof(list)/sizeof(list[0]);i++) { - case AL_MONO8: - *chans = FmtMono; - *type = FmtByte; - return AL_TRUE; - case AL_MONO16: - *chans = FmtMono; - *type = FmtShort; - return AL_TRUE; - case AL_MONO32F: - *chans = FmtMono; - *type = FmtFloat; - return AL_TRUE; - case AL_STEREO8: - *chans = FmtStereo; - *type = FmtByte; - return AL_TRUE; - case AL_STEREO16: - *chans = FmtStereo; - *type = FmtShort; - return AL_TRUE; - case AL_STEREO32F: - *chans = FmtStereo; - *type = FmtFloat; - return AL_TRUE; - case AL_FORMAT_QUAD8_LOKI: - case AL_QUAD8: - *chans = FmtQuad; - *type = FmtByte; - return AL_TRUE; - case AL_FORMAT_QUAD16_LOKI: - case AL_QUAD16: - *chans = FmtQuad; - *type = FmtShort; - return AL_TRUE; - case AL_QUAD32F: - *chans = FmtQuad; - *type = FmtFloat; - return AL_TRUE; - case AL_REAR8: - *chans = FmtRear; - *type = FmtByte; - return AL_TRUE; - case AL_REAR16: - *chans = FmtRear; - *type = FmtShort; - return AL_TRUE; - case AL_REAR32F: - *chans = FmtRear; - *type = FmtFloat; - return AL_TRUE; - case AL_5POINT1_8: - *chans = FmtX51; - *type = FmtByte; - return AL_TRUE; - case AL_5POINT1_16: - *chans = FmtX51; - *type = FmtShort; - return AL_TRUE; - case AL_5POINT1_32F: - *chans = FmtX51; - *type = FmtFloat; - return AL_TRUE; - case AL_6POINT1_8: - *chans = FmtX61; - *type = FmtByte; - return AL_TRUE; - case AL_6POINT1_16: - *chans = FmtX61; - *type = FmtShort; - return AL_TRUE; - case AL_6POINT1_32F: - *chans = FmtX61; - *type = FmtFloat; - return AL_TRUE; - case AL_7POINT1_8: - *chans = FmtX71; - *type = FmtByte; - return AL_TRUE; - case AL_7POINT1_16: - *chans = FmtX71; - *type = FmtShort; - return AL_TRUE; - case AL_7POINT1_32F: - *chans = FmtX71; - *type = FmtFloat; + if(list[i].format == format) + { + *chans = list[i].channels; + *type = list[i].type; return AL_TRUE; + } } + return AL_FALSE; } -- cgit v1.2.3