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

Separate device format into 'channel config' and 'sample type' components

Browse Source
This commit is contained in:
Chris Robinson 2010-12-04 19:50:00 -08:00
parent 191803ad53
commit 88e3a22772
13 changed files with 465 additions and 377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

152
Alc/ALc.c
View File

@ -778,6 +778,112 @@ ALvoid *LookupUIntMapKey(UIntMap *map, ALuint key)
} }
ALuint BytesFromDevFmt(enum DevFmtType type)
{
switch(type)
{
case DevFmtByte: return sizeof(ALbyte);
case DevFmtUByte: return sizeof(ALubyte);
case DevFmtShort: return sizeof(ALshort);
case DevFmtUShort: return sizeof(ALushort);
case DevFmtFloat: return sizeof(ALfloat);
}
return 0;
}
ALuint ChannelsFromDevFmt(enum DevFmtChannels chans)
{
switch(chans)
{
case DevFmtMono: return 1;
case DevFmtStereo: return 2;
case DevFmtQuad: return 4;
case DevFmtX51: return 6;
case DevFmtX61: return 7;
case DevFmtX71: return 8;
}
return 0;
}
ALboolean DecomposeDevFormat(ALenum format, enum DevFmtChannels *chans,
enum DevFmtType *type)
{
switch(format)
{
case AL_FORMAT_MONO8:
*chans = DevFmtMono;
*type = DevFmtUByte;
return AL_TRUE;
case AL_FORMAT_MONO16:
*chans = DevFmtMono;
*type = DevFmtShort;
return AL_TRUE;
case AL_FORMAT_MONO_FLOAT32:
*chans = DevFmtMono;
*type = DevFmtFloat;
return AL_TRUE;
case AL_FORMAT_STEREO8:
*chans = DevFmtStereo;
*type = DevFmtUByte;
return AL_TRUE;
case AL_FORMAT_STEREO16:
*chans = DevFmtStereo;
*type = DevFmtShort;
return AL_TRUE;
case AL_FORMAT_STEREO_FLOAT32:
*chans = DevFmtStereo;
*type = DevFmtFloat;
return AL_TRUE;
case AL_FORMAT_QUAD8:
*chans = DevFmtQuad;
*type = DevFmtUByte;
return AL_TRUE;
case AL_FORMAT_QUAD16:
*chans = DevFmtQuad;
*type = DevFmtShort;
return AL_TRUE;
case AL_FORMAT_QUAD32:
*chans = DevFmtQuad;
*type = DevFmtFloat;
return AL_TRUE;
case AL_FORMAT_51CHN8:
*chans = DevFmtX51;
*type = DevFmtUByte;
return AL_TRUE;
case AL_FORMAT_51CHN16:
*chans = DevFmtX51;
*type = DevFmtShort;
return AL_TRUE;
case AL_FORMAT_51CHN32:
*chans = DevFmtX51;
*type = DevFmtFloat;
return AL_TRUE;
case AL_FORMAT_61CHN8:
*chans = DevFmtX61;
*type = DevFmtUByte;
return AL_TRUE;
case AL_FORMAT_61CHN16:
*chans = DevFmtX61;
*type = DevFmtShort;
return AL_TRUE;
case AL_FORMAT_61CHN32:
*chans = DevFmtX61;
*type = DevFmtFloat;
return AL_TRUE;
case AL_FORMAT_71CHN8:
*chans = DevFmtX71;
*type = DevFmtUByte;
return AL_TRUE;
case AL_FORMAT_71CHN16:
*chans = DevFmtX71;
*type = DevFmtShort;
return AL_TRUE;
case AL_FORMAT_71CHN32:
*chans = DevFmtX71;
*type = DevFmtFloat;
return AL_TRUE;
}
return AL_FALSE;
}
/* /*
IsDevice IsDevice
@ -972,7 +1078,7 @@ static ALCboolean UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
device->Bs2b = NULL; device->Bs2b = NULL;
} }
if(aluChannelsFromFormat(device->Format) <= 2) if(ChannelsFromDevFmt(device->FmtChans) <= 2)
{ {
device->HeadDampen = GetConfigValueFloat(NULL, "head_dampen", DEFAULT_HEAD_DAMPEN); device->HeadDampen = GetConfigValueFloat(NULL, "head_dampen", DEFAULT_HEAD_DAMPEN);
device->HeadDampen = __min(device->HeadDampen, 1.0f); device->HeadDampen = __min(device->HeadDampen, 1.0f);
@ -1127,7 +1233,13 @@ ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName,
device->szDeviceName = NULL; device->szDeviceName = NULL;
device->Frequency = frequency; device->Frequency = frequency;
device->Format = format; if(DecomposeDevFormat(format, &device->FmtChans, &device->FmtType) == AL_FALSE)
{
free(device);
alcSetError(NULL, ALC_INVALID_ENUM);
return NULL;
}
device->UpdateSize = SampleSize; device->UpdateSize = SampleSize;
device->NumUpdates = 1; device->NumUpdates = 1;
@ -1882,26 +1994,26 @@ ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
// Sets the default channel order used by most non-WaveFormatEx-based APIs // Sets the default channel order used by most non-WaveFormatEx-based APIs
void SetDefaultChannelOrder(ALCdevice *device) void SetDefaultChannelOrder(ALCdevice *device)
{ {
switch(aluChannelsFromFormat(device->Format)) switch(device->FmtChans)
{ {
case 1: device->DevChannels[FRONT_CENTER] = 0; break; case DevFmtMono: device->DevChannels[FRONT_CENTER] = 0; break;
case 2: device->DevChannels[FRONT_LEFT] = 0; case DevFmtStereo: device->DevChannels[FRONT_LEFT] = 0;
device->DevChannels[FRONT_RIGHT] = 1; break; device->DevChannels[FRONT_RIGHT] = 1; break;
case 4: device->DevChannels[FRONT_LEFT] = 0; case DevFmtQuad: device->DevChannels[FRONT_LEFT] = 0;
device->DevChannels[FRONT_RIGHT] = 1; device->DevChannels[FRONT_RIGHT] = 1;
device->DevChannels[BACK_LEFT] = 2; device->DevChannels[BACK_LEFT] = 2;
device->DevChannels[BACK_RIGHT] = 3; break; device->DevChannels[BACK_RIGHT] = 3; break;
case 6: device->DevChannels[FRONT_LEFT] = 0; case DevFmtX51: device->DevChannels[FRONT_LEFT] = 0;
device->DevChannels[FRONT_RIGHT] = 1; device->DevChannels[FRONT_RIGHT] = 1;
device->DevChannels[BACK_LEFT] = 2; device->DevChannels[BACK_LEFT] = 2;
device->DevChannels[BACK_RIGHT] = 3; device->DevChannels[BACK_RIGHT] = 3;
device->DevChannels[FRONT_CENTER] = 4; device->DevChannels[FRONT_CENTER] = 4;
device->DevChannels[LFE] = 5; break; device->DevChannels[LFE] = 5; break;
case 7: device->DevChannels[FRONT_LEFT] = 0; case DevFmtX61: device->DevChannels[FRONT_LEFT] = 0;
device->DevChannels[FRONT_RIGHT] = 1; device->DevChannels[FRONT_RIGHT] = 1;
device->DevChannels[FRONT_CENTER] = 2; device->DevChannels[FRONT_CENTER] = 2;
device->DevChannels[LFE] = 3; device->DevChannels[LFE] = 3;
@ -1909,7 +2021,7 @@ void SetDefaultChannelOrder(ALCdevice *device)
device->DevChannels[SIDE_LEFT] = 5; device->DevChannels[SIDE_LEFT] = 5;
device->DevChannels[SIDE_RIGHT] = 6; break; device->DevChannels[SIDE_RIGHT] = 6; break;
case 8: device->DevChannels[FRONT_LEFT] = 0; case DevFmtX71: device->DevChannels[FRONT_LEFT] = 0;
device->DevChannels[FRONT_RIGHT] = 1; device->DevChannels[FRONT_RIGHT] = 1;
device->DevChannels[BACK_LEFT] = 2; device->DevChannels[BACK_LEFT] = 2;
device->DevChannels[BACK_RIGHT] = 3; device->DevChannels[BACK_RIGHT] = 3;
@ -1922,26 +2034,26 @@ void SetDefaultChannelOrder(ALCdevice *device)
// Sets the default order used by WaveFormatEx // Sets the default order used by WaveFormatEx
void SetDefaultWFXChannelOrder(ALCdevice *device) void SetDefaultWFXChannelOrder(ALCdevice *device)
{ {
switch(aluChannelsFromFormat(device->Format)) switch(device->FmtChans)
{ {
case 1: device->DevChannels[FRONT_CENTER] = 0; break; case DevFmtMono: device->DevChannels[FRONT_CENTER] = 0; break;
case 2: device->DevChannels[FRONT_LEFT] = 0; case DevFmtStereo: device->DevChannels[FRONT_LEFT] = 0;
device->DevChannels[FRONT_RIGHT] = 1; break; device->DevChannels[FRONT_RIGHT] = 1; break;
case 4: device->DevChannels[FRONT_LEFT] = 0; case DevFmtQuad: device->DevChannels[FRONT_LEFT] = 0;
device->DevChannels[FRONT_RIGHT] = 1; device->DevChannels[FRONT_RIGHT] = 1;
device->DevChannels[BACK_LEFT] = 2; device->DevChannels[BACK_LEFT] = 2;
device->DevChannels[BACK_RIGHT] = 3; break; device->DevChannels[BACK_RIGHT] = 3; break;
case 6: device->DevChannels[FRONT_LEFT] = 0; case DevFmtX51: device->DevChannels[FRONT_LEFT] = 0;
device->DevChannels[FRONT_RIGHT] = 1; device->DevChannels[FRONT_RIGHT] = 1;
device->DevChannels[FRONT_CENTER] = 2; device->DevChannels[FRONT_CENTER] = 2;
device->DevChannels[LFE] = 3; device->DevChannels[LFE] = 3;
device->DevChannels[BACK_LEFT] = 4; device->DevChannels[BACK_LEFT] = 4;
device->DevChannels[BACK_RIGHT] = 5; break; device->DevChannels[BACK_RIGHT] = 5; break;
case 7: device->DevChannels[FRONT_LEFT] = 0; case DevFmtX61: device->DevChannels[FRONT_LEFT] = 0;
device->DevChannels[FRONT_RIGHT] = 1; device->DevChannels[FRONT_RIGHT] = 1;
device->DevChannels[FRONT_CENTER] = 2; device->DevChannels[FRONT_CENTER] = 2;
device->DevChannels[LFE] = 3; device->DevChannels[LFE] = 3;
@ -1949,7 +2061,7 @@ void SetDefaultWFXChannelOrder(ALCdevice *device)
device->DevChannels[SIDE_LEFT] = 5; device->DevChannels[SIDE_LEFT] = 5;
device->DevChannels[SIDE_RIGHT] = 6; break; device->DevChannels[SIDE_RIGHT] = 6; break;
case 8: device->DevChannels[FRONT_LEFT] = 0; case DevFmtX71: device->DevChannels[FRONT_LEFT] = 0;
device->DevChannels[FRONT_RIGHT] = 1; device->DevChannels[FRONT_RIGHT] = 1;
device->DevChannels[FRONT_CENTER] = 2; device->DevChannels[FRONT_CENTER] = 2;
device->DevChannels[LFE] = 3; device->DevChannels[LFE] = 3;
@ -2031,7 +2143,13 @@ ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)
device->Frequency = 8000; device->Frequency = 8000;
fmt = GetConfigValue(NULL, "format", "AL_FORMAT_STEREO16"); fmt = GetConfigValue(NULL, "format", "AL_FORMAT_STEREO16");
device->Format = GetFormatFromString(fmt); if(DecomposeDevFormat(GetFormatFromString(fmt),
&device->FmtChans, &device->FmtType) == AL_FALSE)
{
/* Should never happen... */
device->FmtChans = DevFmtStereo;
device->FmtType = DevFmtShort;
}
device->NumUpdates = GetConfigValueInt(NULL, "periods", 4); device->NumUpdates = GetConfigValueInt(NULL, "periods", 4);
if(device->NumUpdates < 2) if(device->NumUpdates < 2)

63
Alc/ALu.c
View File

@ -186,6 +186,7 @@ ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
{ {
ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume; ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume;
ALbufferlistitem *BufferListItem; ALbufferlistitem *BufferListItem;
enum DevFmtChannels DevChans;
enum FmtChannels Channels; enum FmtChannels Channels;
ALfloat DryGain, DryGainHF; ALfloat DryGain, DryGainHF;
ALfloat WetGain[MAX_SENDS]; ALfloat WetGain[MAX_SENDS];
@ -193,12 +194,11 @@ ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
ALint NumSends, Frequency; ALint NumSends, Frequency;
ALboolean DupStereo; ALboolean DupStereo;
ALfloat Pitch; ALfloat Pitch;
ALenum Format;
ALfloat cw; ALfloat cw;
ALint i; ALint i;
/* Get device properties */ /* Get device properties */
Format = ALContext->Device->Format; DevChans = ALContext->Device->FmtChans;
DupStereo = ALContext->Device->DuplicateStereo; DupStereo = ALContext->Device->DuplicateStereo;
NumSends = ALContext->Device->NumAuxSends; NumSends = ALContext->Device->NumAuxSends;
Frequency = ALContext->Device->Frequency; Frequency = ALContext->Device->Frequency;
@ -268,24 +268,16 @@ ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
} }
else else
{ {
switch(Format) switch(DevChans)
{ {
case AL_FORMAT_MONO8: case DevFmtMono:
case AL_FORMAT_MONO16: case DevFmtStereo:
case AL_FORMAT_MONO_FLOAT32:
case AL_FORMAT_STEREO8:
case AL_FORMAT_STEREO16:
case AL_FORMAT_STEREO_FLOAT32:
ALSource->Params.DryGains[FRONT_LEFT] = DryGain * ListenerGain; ALSource->Params.DryGains[FRONT_LEFT] = DryGain * ListenerGain;
ALSource->Params.DryGains[FRONT_RIGHT] = DryGain * ListenerGain; ALSource->Params.DryGains[FRONT_RIGHT] = DryGain * ListenerGain;
break; break;
case AL_FORMAT_QUAD8: case DevFmtQuad:
case AL_FORMAT_QUAD16: case DevFmtX51:
case AL_FORMAT_QUAD32:
case AL_FORMAT_51CHN8:
case AL_FORMAT_51CHN16:
case AL_FORMAT_51CHN32:
DryGain *= aluSqrt(2.0f/4.0f); DryGain *= aluSqrt(2.0f/4.0f);
ALSource->Params.DryGains[FRONT_LEFT] = DryGain * ListenerGain; ALSource->Params.DryGains[FRONT_LEFT] = DryGain * ListenerGain;
ALSource->Params.DryGains[FRONT_RIGHT] = DryGain * ListenerGain; ALSource->Params.DryGains[FRONT_RIGHT] = DryGain * ListenerGain;
@ -293,9 +285,7 @@ ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
ALSource->Params.DryGains[BACK_RIGHT] = DryGain * ListenerGain; ALSource->Params.DryGains[BACK_RIGHT] = DryGain * ListenerGain;
break; break;
case AL_FORMAT_61CHN8: case DevFmtX61:
case AL_FORMAT_61CHN16:
case AL_FORMAT_61CHN32:
DryGain *= aluSqrt(2.0f/4.0f); DryGain *= aluSqrt(2.0f/4.0f);
ALSource->Params.DryGains[FRONT_LEFT] = DryGain * ListenerGain; ALSource->Params.DryGains[FRONT_LEFT] = DryGain * ListenerGain;
ALSource->Params.DryGains[FRONT_RIGHT] = DryGain * ListenerGain; ALSource->Params.DryGains[FRONT_RIGHT] = DryGain * ListenerGain;
@ -303,9 +293,7 @@ ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
ALSource->Params.DryGains[SIDE_RIGHT] = DryGain * ListenerGain; ALSource->Params.DryGains[SIDE_RIGHT] = DryGain * ListenerGain;
break; break;
case AL_FORMAT_71CHN8: case DevFmtX71:
case AL_FORMAT_71CHN16:
case AL_FORMAT_71CHN32:
DryGain *= aluSqrt(2.0f/6.0f); DryGain *= aluSqrt(2.0f/6.0f);
ALSource->Params.DryGains[FRONT_LEFT] = DryGain * ListenerGain; ALSource->Params.DryGains[FRONT_LEFT] = DryGain * ListenerGain;
ALSource->Params.DryGains[FRONT_RIGHT] = DryGain * ListenerGain; ALSource->Params.DryGains[FRONT_RIGHT] = DryGain * ListenerGain;
@ -314,9 +302,6 @@ ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
ALSource->Params.DryGains[SIDE_LEFT] = DryGain * ListenerGain; ALSource->Params.DryGains[SIDE_LEFT] = DryGain * ListenerGain;
ALSource->Params.DryGains[SIDE_RIGHT] = DryGain * ListenerGain; ALSource->Params.DryGains[SIDE_RIGHT] = DryGain * ListenerGain;
break; break;
default:
break;
} }
} }
} }
@ -915,24 +900,24 @@ DECL_TEMPLATE(ALbyte, StereoChans,2, aluF2B)
#define DECL_TEMPLATE(T, func) \ #define DECL_TEMPLATE(T, func) \
static void Write_##T(ALCdevice *device, T *buffer, ALuint SamplesToDo) \ static void Write_##T(ALCdevice *device, T *buffer, ALuint SamplesToDo) \
{ \ { \
switch(aluChannelsFromFormat(device->Format)) \ switch(device->FmtChans) \
{ \ { \
case 1: \ case DevFmtMono: \
Write_##T##_MonoChans(device, buffer, SamplesToDo); \ Write_##T##_MonoChans(device, buffer, SamplesToDo); \
break; \ break; \
case 2: \ case DevFmtStereo: \
Write_##T##_StereoChans(device, buffer, SamplesToDo); \ Write_##T##_StereoChans(device, buffer, SamplesToDo); \
break; \ break; \
case 4: \ case DevFmtQuad: \
Write_##T##_QuadChans(device, buffer, SamplesToDo); \ Write_##T##_QuadChans(device, buffer, SamplesToDo); \
break; \ break; \
case 6: \ case DevFmtX51: \
Write_##T##_X51Chans(device, buffer, SamplesToDo); \ Write_##T##_X51Chans(device, buffer, SamplesToDo); \
break; \ break; \
case 7: \ case DevFmtX61: \
Write_##T##_X61Chans(device, buffer, SamplesToDo); \ Write_##T##_X61Chans(device, buffer, SamplesToDo); \
break; \ break; \
case 8: \ case DevFmtX71: \
Write_##T##_X71Chans(device, buffer, SamplesToDo); \ Write_##T##_X71Chans(device, buffer, SamplesToDo); \
break; \ break; \
} \ } \
@ -1045,17 +1030,21 @@ ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
device->PendingClicks[i] = 0.0f; device->PendingClicks[i] = 0.0f;
} }
switch(aluBytesFromFormat(device->Format)) switch(device->FmtType)
{ {
(void)Write_ALbyte; case DevFmtByte:
case 1: Write_ALbyte(device, buffer, SamplesToDo);
break;
case DevFmtUByte:
Write_ALubyte(device, buffer, SamplesToDo); Write_ALubyte(device, buffer, SamplesToDo);
break; break;
case 2: case DevFmtShort:
Write_ALshort(device, buffer, SamplesToDo); Write_ALshort(device, buffer, SamplesToDo);
break; break;
(void)Write_ALushort; case DevFmtUShort:
case 4: Write_ALushort(device, buffer, SamplesToDo);
break;
case DevFmtFloat:
Write_ALfloat(device, buffer, SamplesToDo); Write_ALfloat(device, buffer, SamplesToDo);
break; break;
} }

86
Alc/alsa.c
View File

@ -543,20 +543,24 @@ static ALCboolean alsa_reset_playback(ALCdevice *device)
int i; int i;
switch(aluBytesFromFormat(device->Format)) format = -1;
switch(device->FmtType)
{ {
case 1: case DevFmtByte:
format = SND_PCM_FORMAT_S8;
break;
case DevFmtUByte:
format = SND_PCM_FORMAT_U8; format = SND_PCM_FORMAT_U8;
break; break;
case 2: case DevFmtShort:
format = SND_PCM_FORMAT_S16; format = SND_PCM_FORMAT_S16;
break; break;
case 4: case DevFmtUShort:
format = SND_PCM_FORMAT_U16;
break;
case DevFmtFloat:
format = SND_PCM_FORMAT_FLOAT; format = SND_PCM_FORMAT_FLOAT;
break; break;
default:
AL_PRINT("Unknown format: 0x%x\n", device->Format);
return ALC_FALSE;
} }
allowmmap = GetConfigValueBool("alsa", "mmap", 1); allowmmap = GetConfigValueBool("alsa", "mmap", 1);
@ -584,39 +588,15 @@ static ALCboolean alsa_reset_playback(ALCdevice *device)
/* set format (implicitly sets sample bits) */ /* set format (implicitly sets sample bits) */
if(i >= 0 && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0) if(i >= 0 && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0)
{ {
switch(aluChannelsFromFormat(device->Format)) device->FmtType = DevFmtFloat;
{
case 1: device->Format = AL_FORMAT_MONO_FLOAT32; break;
case 2: device->Format = AL_FORMAT_STEREO_FLOAT32; break;
case 4: device->Format = AL_FORMAT_QUAD32; break;
case 6: device->Format = AL_FORMAT_51CHN32; break;
case 7: device->Format = AL_FORMAT_61CHN32; break;
case 8: device->Format = AL_FORMAT_71CHN32; break;
}
if(format == SND_PCM_FORMAT_FLOAT || if(format == SND_PCM_FORMAT_FLOAT ||
(i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_FLOAT)) < 0) (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_FLOAT)) < 0)
{ {
switch(aluChannelsFromFormat(device->Format)) device->FmtType = DevFmtShort;
{
case 1: device->Format = AL_FORMAT_MONO16; break;
case 2: device->Format = AL_FORMAT_STEREO16; break;
case 4: device->Format = AL_FORMAT_QUAD16; break;
case 6: device->Format = AL_FORMAT_51CHN16; break;
case 7: device->Format = AL_FORMAT_61CHN16; break;
case 8: device->Format = AL_FORMAT_71CHN16; break;
}
if(format == SND_PCM_FORMAT_S16 || if(format == SND_PCM_FORMAT_S16 ||
(i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_S16)) < 0) (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_S16)) < 0)
{ {
switch(aluChannelsFromFormat(device->Format)) device->FmtType = DevFmtUByte;
{
case 1: device->Format = AL_FORMAT_MONO8; break;
case 2: device->Format = AL_FORMAT_STEREO8; break;
case 4: device->Format = AL_FORMAT_QUAD8; break;
case 6: device->Format = AL_FORMAT_51CHN8; break;
case 7: device->Format = AL_FORMAT_61CHN8; break;
case 8: device->Format = AL_FORMAT_71CHN8; break;
}
if(format == SND_PCM_FORMAT_U8 || if(format == SND_PCM_FORMAT_U8 ||
(i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_U8)) < 0) (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, SND_PCM_FORMAT_U8)) < 0)
err = "set format"; err = "set format";
@ -624,22 +604,12 @@ static ALCboolean alsa_reset_playback(ALCdevice *device)
} }
} }
/* set channels (implicitly sets frame bits) */ /* set channels (implicitly sets frame bits) */
if(i >= 0 && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(device->Format))) < 0) if(i >= 0 && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, ChannelsFromDevFmt(device->FmtChans))) < 0)
{ {
switch(aluBytesFromFormat(device->Format)) device->FmtChans = DevFmtStereo;
{
case 1: device->Format = AL_FORMAT_STEREO8; break;
case 2: device->Format = AL_FORMAT_STEREO16; break;
case 4: device->Format = AL_FORMAT_STEREO_FLOAT32; break;
}
if((i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, 2)) < 0) if((i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, 2)) < 0)
{ {
switch(aluBytesFromFormat(device->Format)) device->FmtChans = DevFmtMono;
{
case 1: device->Format = AL_FORMAT_MONO8; break;
case 2: device->Format = AL_FORMAT_MONO16; break;
case 4: device->Format = AL_FORMAT_MONO_FLOAT32; break;
}
if((i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, 1)) < 0) if((i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, 1)) < 0)
err = "set channels"; err = "set channels";
} }
@ -803,20 +773,24 @@ static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceNam
return ALC_FALSE; return ALC_FALSE;
} }
switch(aluBytesFromFormat(pDevice->Format)) format = -1;
switch(pDevice->FmtType)
{ {
case 1: case DevFmtByte:
format = SND_PCM_FORMAT_S8;
break;
case DevFmtUByte:
format = SND_PCM_FORMAT_U8; format = SND_PCM_FORMAT_U8;
break; break;
case 2: case DevFmtShort:
format = SND_PCM_FORMAT_S16; format = SND_PCM_FORMAT_S16;
break; break;
case 4: case DevFmtUShort:
format = SND_PCM_FORMAT_U16;
break;
case DevFmtFloat:
format = SND_PCM_FORMAT_FLOAT; format = SND_PCM_FORMAT_FLOAT;
break; break;
default:
AL_PRINT("Unknown format: 0x%x\n", pDevice->Format);
goto error;
} }
err = NULL; err = NULL;
@ -832,7 +806,7 @@ static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceNam
if(i >= 0 && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0) if(i >= 0 && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, format)) < 0)
err = "set format"; err = "set format";
/* set channels (implicitly sets frame bits) */ /* set channels (implicitly sets frame bits) */
if(i >= 0 && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format))) < 0) if(i >= 0 && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, ChannelsFromDevFmt(pDevice->FmtChans))) < 0)
err = "set channels"; err = "set channels";
/* set rate (implicitly constrains period/buffer parameters) */ /* set rate (implicitly constrains period/buffer parameters) */
if(i >= 0 && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, pDevice->Frequency, 0)) < 0) if(i >= 0 && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, pDevice->Frequency, 0)) < 0)
@ -859,7 +833,7 @@ static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceNam
psnd_pcm_hw_params_free(p); psnd_pcm_hw_params_free(p);
frameSize = aluFrameSizeFromFormat(pDevice->Format); frameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
data->ring = CreateRingBuffer(frameSize, pDevice->UpdateSize*pDevice->NumUpdates); data->ring = CreateRingBuffer(frameSize, pDevice->UpdateSize*pDevice->NumUpdates);
if(!data->ring) if(!data->ring)

98
Alc/dsound.c
View File

@ -188,7 +188,7 @@ static ALuint DSoundProc(ALvoid *ptr)
return 1; return 1;
} }
FrameSize = aluFrameSizeFromFormat(pDevice->Format); FrameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
FragSize = pDevice->UpdateSize * FrameSize; FragSize = pDevice->UpdateSize * FrameSize;
IDirectSoundBuffer_GetCurrentPosition(pData->DSsbuffer, &LastCursor, NULL); IDirectSoundBuffer_GetCurrentPosition(pData->DSsbuffer, &LastCursor, NULL);
@ -332,30 +332,48 @@ static ALCboolean DSoundResetPlayback(ALCdevice *device)
DSoundData *pData = (DSoundData*)device->ExtraData; DSoundData *pData = (DSoundData*)device->ExtraData;
DSBUFFERDESC DSBDescription; DSBUFFERDESC DSBDescription;
WAVEFORMATEXTENSIBLE OutputType; WAVEFORMATEXTENSIBLE OutputType;
DWORD frameSize = 0;
ALenum format = 0;
DWORD speakers; DWORD speakers;
HRESULT hr; HRESULT hr;
memset(&OutputType, 0, sizeof(OutputType)); memset(&OutputType, 0, sizeof(OutputType));
switch(device->FmtType)
{
case DevFmtByte:
device->FmtType = DevFmtUByte;
break;
case DevFmtUShort:
device->FmtType = DevFmtShort;
break;
case DevFmtUByte:
case DevFmtShort:
case DevFmtFloat:
break;
}
hr = IDirectSound_GetSpeakerConfig(pData->lpDS, &speakers); hr = IDirectSound_GetSpeakerConfig(pData->lpDS, &speakers);
if(SUCCEEDED(hr) && ConfigValueExists(NULL, "format")) if(SUCCEEDED(hr) && ConfigValueExists(NULL, "format"))
{ {
if(aluChannelsFromFormat(device->Format) == 1) switch(device->FmtChans)
speakers = DSSPEAKER_COMBINED(DSSPEAKER_MONO, 0);
else if(aluChannelsFromFormat(device->Format) == 2)
speakers = DSSPEAKER_COMBINED(DSSPEAKER_STEREO, 0);
else if(aluChannelsFromFormat(device->Format) == 4)
speakers = DSSPEAKER_COMBINED(DSSPEAKER_QUAD, 0);
else if(aluChannelsFromFormat(device->Format) == 6)
speakers = DSSPEAKER_COMBINED(DSSPEAKER_5POINT1, 0);
else if(aluChannelsFromFormat(device->Format) == 8)
speakers = DSSPEAKER_COMBINED(DSSPEAKER_7POINT1, 0);
else
{ {
AL_PRINT("Unknown format: 0x%x\n", device->Format); case DevFmtMono:
return ALC_FALSE; speakers = DSSPEAKER_COMBINED(DSSPEAKER_MONO, 0);
break;
case DevFmtStereo:
speakers = DSSPEAKER_COMBINED(DSSPEAKER_STEREO, 0);
break;
case DevFmtQuad:
speakers = DSSPEAKER_COMBINED(DSSPEAKER_QUAD, 0);
break;
case DevFmtX51:
speakers = DSSPEAKER_COMBINED(DSSPEAKER_5POINT1, 0);
break;
case DevFmtX61:
/* ??? */;
break;
case DevFmtX71:
speakers = DSSPEAKER_COMBINED(DSSPEAKER_7POINT1, 0);
break;
} }
} }
if(SUCCEEDED(hr)) if(SUCCEEDED(hr))
@ -363,33 +381,18 @@ static ALCboolean DSoundResetPlayback(ALCdevice *device)
speakers = DSSPEAKER_CONFIG(speakers); speakers = DSSPEAKER_CONFIG(speakers);
if(speakers == DSSPEAKER_MONO) if(speakers == DSSPEAKER_MONO)
{ {
if(aluBytesFromFormat(device->Format) == 1) device->FmtChans = DevFmtMono;
format = AL_FORMAT_MONO8;
else if(aluBytesFromFormat(device->Format) == 2)
format = AL_FORMAT_MONO16;
else if(aluBytesFromFormat(device->Format) == 4)
format = AL_FORMAT_MONO_FLOAT32;
OutputType.dwChannelMask = SPEAKER_FRONT_CENTER; OutputType.dwChannelMask = SPEAKER_FRONT_CENTER;
} }
else if(speakers == DSSPEAKER_STEREO) else if(speakers == DSSPEAKER_STEREO || speakers == DSSPEAKER_HEADPHONE)
{ {
if(aluBytesFromFormat(device->Format) == 1) device->FmtChans = DevFmtStereo;
format = AL_FORMAT_STEREO8;
else if(aluBytesFromFormat(device->Format) == 2)
format = AL_FORMAT_STEREO16;
else if(aluBytesFromFormat(device->Format) == 4)
format = AL_FORMAT_STEREO_FLOAT32;
OutputType.dwChannelMask = SPEAKER_FRONT_LEFT | OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
SPEAKER_FRONT_RIGHT; SPEAKER_FRONT_RIGHT;
} }
else if(speakers == DSSPEAKER_QUAD) else if(speakers == DSSPEAKER_QUAD)
{ {
if(aluBytesFromFormat(device->Format) == 1) device->FmtChans = DevFmtQuad;
format = AL_FORMAT_QUAD8;
else if(aluBytesFromFormat(device->Format) == 2)
format = AL_FORMAT_QUAD16;
else if(aluBytesFromFormat(device->Format) == 4)
format = AL_FORMAT_QUAD32;
OutputType.dwChannelMask = SPEAKER_FRONT_LEFT | OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_RIGHT |
SPEAKER_BACK_LEFT | SPEAKER_BACK_LEFT |
@ -397,12 +400,7 @@ static ALCboolean DSoundResetPlayback(ALCdevice *device)
} }
else if(speakers == DSSPEAKER_5POINT1) else if(speakers == DSSPEAKER_5POINT1)
{ {
if(aluBytesFromFormat(device->Format) == 1) device->FmtChans = DevFmtX51;
format = AL_FORMAT_51CHN8;
else if(aluBytesFromFormat(device->Format) == 2)
format = AL_FORMAT_51CHN16;
else if(aluBytesFromFormat(device->Format) == 4)
format = AL_FORMAT_51CHN32;
OutputType.dwChannelMask = SPEAKER_FRONT_LEFT | OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_RIGHT |
SPEAKER_FRONT_CENTER | SPEAKER_FRONT_CENTER |
@ -412,12 +410,7 @@ static ALCboolean DSoundResetPlayback(ALCdevice *device)
} }
else if(speakers == DSSPEAKER_7POINT1) else if(speakers == DSSPEAKER_7POINT1)
{ {
if(aluBytesFromFormat(device->Format) == 1) device->FmtChans = DevFmtX71;
format = AL_FORMAT_71CHN8;
else if(aluBytesFromFormat(device->Format) == 2)
format = AL_FORMAT_71CHN16;
else if(aluBytesFromFormat(device->Format) == 4)
format = AL_FORMAT_71CHN32;
OutputType.dwChannelMask = SPEAKER_FRONT_LEFT | OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_RIGHT |
SPEAKER_FRONT_CENTER | SPEAKER_FRONT_CENTER |
@ -427,13 +420,10 @@ static ALCboolean DSoundResetPlayback(ALCdevice *device)
SPEAKER_SIDE_LEFT | SPEAKER_SIDE_LEFT |
SPEAKER_SIDE_RIGHT; SPEAKER_SIDE_RIGHT;
} }
else
format = device->Format;
frameSize = aluFrameSizeFromFormat(format);
OutputType.Format.wFormatTag = WAVE_FORMAT_PCM; OutputType.Format.wFormatTag = WAVE_FORMAT_PCM;
OutputType.Format.nChannels = aluChannelsFromFormat(format); OutputType.Format.nChannels = ChannelsFromDevFmt(device->FmtChans);
OutputType.Format.wBitsPerSample = aluBytesFromFormat(format) * 8; OutputType.Format.wBitsPerSample = BytesFromDevFmt(device->FmtType) * 8;
OutputType.Format.nBlockAlign = OutputType.Format.nChannels*OutputType.Format.wBitsPerSample/8; OutputType.Format.nBlockAlign = OutputType.Format.nChannels*OutputType.Format.wBitsPerSample/8;
OutputType.Format.nSamplesPerSec = device->Frequency; OutputType.Format.nSamplesPerSec = device->Frequency;
OutputType.Format.nAvgBytesPerSec = OutputType.Format.nSamplesPerSec*OutputType.Format.nBlockAlign; OutputType.Format.nAvgBytesPerSec = OutputType.Format.nSamplesPerSec*OutputType.Format.nBlockAlign;
@ -468,14 +458,14 @@ static ALCboolean DSoundResetPlayback(ALCdevice *device)
memset(&DSBDescription,0,sizeof(DSBUFFERDESC)); memset(&DSBDescription,0,sizeof(DSBUFFERDESC));
DSBDescription.dwSize=sizeof(DSBUFFERDESC); DSBDescription.dwSize=sizeof(DSBUFFERDESC);
DSBDescription.dwFlags=DSBCAPS_GLOBALFOCUS|DSBCAPS_GETCURRENTPOSITION2; DSBDescription.dwFlags=DSBCAPS_GLOBALFOCUS|DSBCAPS_GETCURRENTPOSITION2;
DSBDescription.dwBufferBytes=device->UpdateSize * device->NumUpdates * frameSize; DSBDescription.dwBufferBytes=device->UpdateSize * device->NumUpdates *
OutputType.Format.nBlockAlign;
DSBDescription.lpwfxFormat=&OutputType.Format; DSBDescription.lpwfxFormat=&OutputType.Format;
hr = IDirectSound_CreateSoundBuffer(pData->lpDS, &DSBDescription, &pData->DSsbuffer, NULL); hr = IDirectSound_CreateSoundBuffer(pData->lpDS, &DSBDescription, &pData->DSsbuffer, NULL);
} }
if(SUCCEEDED(hr)) if(SUCCEEDED(hr))
{ {
device->Format = format;
SetDefaultWFXChannelOrder(device); SetDefaultWFXChannelOrder(device);
pData->thread = StartThread(DSoundProc, device); pData->thread = StartThread(DSoundProc, device);
if(!pData->thread) if(!pData->thread)

3
Alc/null.c
View File

@ -104,7 +104,8 @@ static ALCboolean null_reset_playback(ALCdevice *device)
{ {
null_data *data = (null_data*)device->ExtraData; null_data *data = (null_data*)device->ExtraData;
data->size = device->UpdateSize * aluFrameSizeFromFormat(device->Format); data->size = device->UpdateSize * FrameSizeFromDevFmt(device->FmtChans,
device->FmtType);
data->buffer = malloc(data->size); data->buffer = malloc(data->size);
if(!data->buffer) if(!data->buffer)
{ {

74
Alc/oss.c
View File

@ -83,7 +83,7 @@ static ALuint OSSProc(ALvoid *ptr)
SetRTPriority(); SetRTPriority();
frameSize = aluFrameSizeFromFormat(pDevice->Format); frameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
while(!data->killNow && pDevice->Connected) while(!data->killNow && pDevice->Connected)
{ {
@ -124,7 +124,7 @@ static ALuint OSSCaptureProc(ALvoid *ptr)
SetRTPriority(); SetRTPriority();
frameSize = aluFrameSizeFromFormat(pDevice->Format); frameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
while(!data->killNow) while(!data->killNow)
{ {
@ -198,33 +198,26 @@ static ALCboolean oss_reset_playback(ALCdevice *device)
char *err; char *err;
int i; int i;
switch(aluBytesFromFormat(device->Format)) switch(device->FmtType)
{ {
case 1: case DevFmtByte:
ossFormat = AFMT_S8;
break;
case DevFmtUByte:
ossFormat = AFMT_U8; ossFormat = AFMT_U8;
break; break;
case 4: case DevFmtUShort:
switch(aluChannelsFromFormat(device->Format)) case DevFmtFloat:
{ device->FmtType = DevFmtShort;
case 1: device->Format = AL_FORMAT_MONO16; break;
case 2: device->Format = AL_FORMAT_STEREO16; break;
case 4: device->Format = AL_FORMAT_QUAD16; break;
case 6: device->Format = AL_FORMAT_51CHN16; break;
case 7: device->Format = AL_FORMAT_61CHN16; break;
case 8: device->Format = AL_FORMAT_71CHN16; break;
}
/* fall-through */ /* fall-through */
case 2: case DevFmtShort:
ossFormat = AFMT_S16_NE; ossFormat = AFMT_S16_NE;
break; break;
default:
AL_PRINT("Unknown format: 0x%x\n", device->Format);
return ALC_FALSE;
} }
periods = device->NumUpdates; periods = device->NumUpdates;
numChannels = aluChannelsFromFormat(device->Format); numChannels = ChannelsFromDevFmt(device->FmtChans);
frameSize = numChannels * aluBytesFromFormat(device->Format); frameSize = numChannels * BytesFromDevFmt(device->FmtType);
ossSpeed = device->Frequency; ossSpeed = device->Frequency;
log2FragmentSize = log2i(device->UpdateSize * frameSize); log2FragmentSize = log2i(device->UpdateSize * frameSize);
@ -251,16 +244,17 @@ static ALCboolean oss_reset_playback(ALCdevice *device)
} }
#undef ok #undef ok
if((int)aluChannelsFromFormat(device->Format) != numChannels) if((int)ChannelsFromDevFmt(device->FmtChans) != numChannels)
{ {
AL_PRINT("Could not set %d channels, got %d instead\n", aluChannelsFromFormat(device->Format), numChannels); AL_PRINT("Could not set %d channels, got %d instead\n", ChannelsFromDevFmt(device->FmtChans), numChannels);
return ALC_FALSE; return ALC_FALSE;
} }
if(!((ossFormat == AFMT_U8 && aluBytesFromFormat(device->Format) == 1) || if(!((ossFormat == AFMT_S8 && device->FmtType == DevFmtByte) ||
(ossFormat == AFMT_S16_NE && aluBytesFromFormat(device->Format) == 2))) (ossFormat == AFMT_U8 && device->FmtType == DevFmtUByte) ||
(ossFormat == AFMT_S16_NE && device->FmtType == DevFmtShort)))
{ {
AL_PRINT("Could not set %d-bit output, got format %#x\n", aluBytesFromFormat(device->Format)*8, ossFormat); AL_PRINT("Could not set %#x format type, got OSS format %#x\n", device->FmtType, ossFormat);
return ALC_FALSE; return ALC_FALSE;
} }
@ -337,24 +331,27 @@ static ALCboolean oss_open_capture(ALCdevice *device, const ALCchar *deviceName)
return ALC_FALSE; return ALC_FALSE;
} }
switch(aluBytesFromFormat(device->Format)) switch(device->FmtType)
{ {
case 1: case DevFmtByte:
ossFormat = AFMT_S8;
break;
case DevFmtUByte:
ossFormat = AFMT_U8; ossFormat = AFMT_U8;
break; break;
case 2: case DevFmtShort:
ossFormat = AFMT_S16_NE; ossFormat = AFMT_S16_NE;
break; break;
default: case DevFmtUShort:
AL_PRINT("Unknown format: 0x%x\n", device->Format); case DevFmtFloat:
close(data->fd);
free(data); free(data);
AL_PRINT("Format type %#x capture not supported on OSS\n", device->FmtType);
return ALC_FALSE; return ALC_FALSE;
} }
periods = 4; periods = 4;
numChannels = aluChannelsFromFormat(device->Format); numChannels = ChannelsFromDevFmt(device->FmtChans);
frameSize = numChannels * aluBytesFromFormat(device->Format); frameSize = numChannels * BytesFromDevFmt(device->FmtType);
ossSpeed = device->Frequency; ossSpeed = device->Frequency;
log2FragmentSize = log2i(device->UpdateSize * device->NumUpdates * log2FragmentSize = log2i(device->UpdateSize * device->NumUpdates *
frameSize / periods); frameSize / periods);
@ -378,18 +375,19 @@ static ALCboolean oss_open_capture(ALCdevice *device, const ALCchar *deviceName)
} }
#undef ok #undef ok
if((int)aluChannelsFromFormat(device->Format) != numChannels) if((int)ChannelsFromDevFmt(device->FmtChans) != numChannels)
{ {
AL_PRINT("Could not set %d channels, got %d instead\n", aluChannelsFromFormat(device->Format), numChannels); AL_PRINT("Could not set %d channels, got %d instead\n", ChannelsFromDevFmt(device->FmtChans), numChannels);
close(data->fd); close(data->fd);
free(data); free(data);
return ALC_FALSE; return ALC_FALSE;
} }
if(!((ossFormat == AFMT_U8 && aluBytesFromFormat(device->Format) == 1) || if(!((ossFormat == AFMT_S8 && device->FmtType == DevFmtByte) ||
(ossFormat == AFMT_S16_NE && aluBytesFromFormat(device->Format) == 2))) (ossFormat == AFMT_U8 && device->FmtType == DevFmtUByte) ||
(ossFormat == AFMT_S16_NE && device->FmtType == DevFmtShort)))
{ {
AL_PRINT("Could not set %d-bit input, got format %#x\n", aluBytesFromFormat(device->Format)*8, ossFormat); AL_PRINT("Could not set %#x format type, got OSS format %#x\n", device->FmtType, ossFormat);
close(data->fd); close(data->fd);
free(data); free(data);
return ALC_FALSE; return ALC_FALSE;

29
Alc/panning.c
View File

@ -178,11 +178,9 @@ ALvoid aluInitPanning(ALCdevice *Device)
Speaker2Chan = Device->Speaker2Chan; Speaker2Chan = Device->Speaker2Chan;
Matrix = Device->ChannelMatrix; Matrix = Device->ChannelMatrix;
switch(Device->Format) switch(Device->FmtChans)
{ {
case AL_FORMAT_MONO8: case DevFmtMono:
case AL_FORMAT_MONO16:
case AL_FORMAT_MONO_FLOAT32:
Matrix[FRONT_LEFT][FRONT_CENTER] = aluSqrt(0.5); Matrix[FRONT_LEFT][FRONT_CENTER] = aluSqrt(0.5);
Matrix[FRONT_RIGHT][FRONT_CENTER] = aluSqrt(0.5); Matrix[FRONT_RIGHT][FRONT_CENTER] = aluSqrt(0.5);
Matrix[SIDE_LEFT][FRONT_CENTER] = aluSqrt(0.5); Matrix[SIDE_LEFT][FRONT_CENTER] = aluSqrt(0.5);
@ -195,9 +193,7 @@ ALvoid aluInitPanning(ALCdevice *Device)
SpeakerAngle[0] = 0.0f * M_PI/180.0f; SpeakerAngle[0] = 0.0f * M_PI/180.0f;
break; break;
case AL_FORMAT_STEREO8: case DevFmtStereo:
case AL_FORMAT_STEREO16:
case AL_FORMAT_STEREO_FLOAT32:
Matrix[FRONT_CENTER][FRONT_LEFT] = aluSqrt(0.5); Matrix[FRONT_CENTER][FRONT_LEFT] = aluSqrt(0.5);
Matrix[FRONT_CENTER][FRONT_RIGHT] = aluSqrt(0.5); Matrix[FRONT_CENTER][FRONT_RIGHT] = aluSqrt(0.5);
Matrix[SIDE_LEFT][FRONT_LEFT] = 1.0f; Matrix[SIDE_LEFT][FRONT_LEFT] = 1.0f;
@ -214,9 +210,7 @@ ALvoid aluInitPanning(ALCdevice *Device)
SetSpeakerArrangement("layout", SpeakerAngle, Speaker2Chan, Device->NumChan); SetSpeakerArrangement("layout", SpeakerAngle, Speaker2Chan, Device->NumChan);
break; break;
case AL_FORMAT_QUAD8: case DevFmtQuad:
case AL_FORMAT_QUAD16:
case AL_FORMAT_QUAD32:
Matrix[FRONT_CENTER][FRONT_LEFT] = aluSqrt(0.5); Matrix[FRONT_CENTER][FRONT_LEFT] = aluSqrt(0.5);
Matrix[FRONT_CENTER][FRONT_RIGHT] = aluSqrt(0.5); Matrix[FRONT_CENTER][FRONT_RIGHT] = aluSqrt(0.5);
Matrix[SIDE_LEFT][FRONT_LEFT] = aluSqrt(0.5); Matrix[SIDE_LEFT][FRONT_LEFT] = aluSqrt(0.5);
@ -237,9 +231,7 @@ ALvoid aluInitPanning(ALCdevice *Device)
SetSpeakerArrangement("layout", SpeakerAngle, Speaker2Chan, Device->NumChan); SetSpeakerArrangement("layout", SpeakerAngle, Speaker2Chan, Device->NumChan);
break; break;
case AL_FORMAT_51CHN8: case DevFmtX51:
case AL_FORMAT_51CHN16:
case AL_FORMAT_51CHN32:
Matrix[SIDE_LEFT][FRONT_LEFT] = aluSqrt(0.5); Matrix[SIDE_LEFT][FRONT_LEFT] = aluSqrt(0.5);
Matrix[SIDE_LEFT][BACK_LEFT] = aluSqrt(0.5); Matrix[SIDE_LEFT][BACK_LEFT] = aluSqrt(0.5);
Matrix[SIDE_RIGHT][FRONT_RIGHT] = aluSqrt(0.5); Matrix[SIDE_RIGHT][FRONT_RIGHT] = aluSqrt(0.5);
@ -260,9 +252,7 @@ ALvoid aluInitPanning(ALCdevice *Device)
SetSpeakerArrangement("layout", SpeakerAngle, Speaker2Chan, Device->NumChan); SetSpeakerArrangement("layout", SpeakerAngle, Speaker2Chan, Device->NumChan);
break; break;
case AL_FORMAT_61CHN8: case DevFmtX61:
case AL_FORMAT_61CHN16:
case AL_FORMAT_61CHN32:
Matrix[BACK_LEFT][BACK_CENTER] = aluSqrt(0.5); Matrix[BACK_LEFT][BACK_CENTER] = aluSqrt(0.5);
Matrix[BACK_LEFT][SIDE_LEFT] = aluSqrt(0.5); Matrix[BACK_LEFT][SIDE_LEFT] = aluSqrt(0.5);
Matrix[BACK_RIGHT][BACK_CENTER] = aluSqrt(0.5); Matrix[BACK_RIGHT][BACK_CENTER] = aluSqrt(0.5);
@ -283,9 +273,7 @@ ALvoid aluInitPanning(ALCdevice *Device)
SetSpeakerArrangement("layout", SpeakerAngle, Speaker2Chan, Device->NumChan); SetSpeakerArrangement("layout", SpeakerAngle, Speaker2Chan, Device->NumChan);
break; break;
case AL_FORMAT_71CHN8: case DevFmtX71:
case AL_FORMAT_71CHN16:
case AL_FORMAT_71CHN32:
Matrix[BACK_CENTER][BACK_LEFT] = aluSqrt(0.5); Matrix[BACK_CENTER][BACK_LEFT] = aluSqrt(0.5);
Matrix[BACK_CENTER][BACK_RIGHT] = aluSqrt(0.5); Matrix[BACK_CENTER][BACK_RIGHT] = aluSqrt(0.5);
Device->NumChan = 7; Device->NumChan = 7;
@ -305,9 +293,6 @@ ALvoid aluInitPanning(ALCdevice *Device)
SpeakerAngle[6] = 150.0f * M_PI/180.0f; SpeakerAngle[6] = 150.0f * M_PI/180.0f;
SetSpeakerArrangement("layout", SpeakerAngle, Speaker2Chan, Device->NumChan); SetSpeakerArrangement("layout", SpeakerAngle, Speaker2Chan, Device->NumChan);
break; break;
default:
assert(0);
} }
if(GetConfigValueBool(NULL, "scalemix", 0)) if(GetConfigValueBool(NULL, "scalemix", 0))

40
Alc/portaudio.c
View File

@ -190,24 +190,25 @@ static ALCboolean pa_open_playback(ALCdevice *device, const ALCchar *deviceName)
(float)device->Frequency; (float)device->Frequency;
outParams.hostApiSpecificStreamInfo = NULL; outParams.hostApiSpecificStreamInfo = NULL;
switch(aluBytesFromFormat(device->Format)) switch(device->FmtType)
{ {
case 1: case DevFmtByte:
outParams.sampleFormat = paInt8;
break;
case DevFmtUByte:
outParams.sampleFormat = paUInt8; outParams.sampleFormat = paUInt8;
break; break;
case 2: case DevFmtUShort:
device->FmtType = DevFmtShort;
/* fall-through */
case DevFmtShort:
outParams.sampleFormat = paInt16; outParams.sampleFormat = paInt16;
break; break;
case 4: case DevFmtFloat:
outParams.sampleFormat = paFloat32; outParams.sampleFormat = paFloat32;
break; break;
default:
AL_PRINT("Unknown format: 0x%x\n", device->Format);
device->ExtraData = NULL;
free(data);
return ALC_FALSE;
} }
outParams.channelCount = aluChannelsFromFormat(device->Format); outParams.channelCount = ChannelsFromDevFmt(device->FmtChans);
SetDefaultChannelOrder(device); SetDefaultChannelOrder(device);
@ -294,7 +295,7 @@ static ALCboolean pa_open_capture(ALCdevice *device, const ALCchar *deviceName)
return ALC_FALSE; return ALC_FALSE;
} }
frame_size = aluFrameSizeFromFormat(device->Format); frame_size = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
data->ring = CreateRingBuffer(frame_size, device->UpdateSize*device->NumUpdates); data->ring = CreateRingBuffer(frame_size, device->UpdateSize*device->NumUpdates);
if(data->ring == NULL) if(data->ring == NULL)
{ {
@ -308,22 +309,25 @@ static ALCboolean pa_open_capture(ALCdevice *device, const ALCchar *deviceName)
inParams.suggestedLatency = 0.0f; inParams.suggestedLatency = 0.0f;
inParams.hostApiSpecificStreamInfo = NULL; inParams.hostApiSpecificStreamInfo = NULL;
switch(aluBytesFromFormat(device->Format)) switch(device->FmtType)
{ {
case 1: case DevFmtByte:
inParams.sampleFormat = paInt8;
break;
case DevFmtUByte:
inParams.sampleFormat = paUInt8; inParams.sampleFormat = paUInt8;
break; break;
case 2: case DevFmtShort:
inParams.sampleFormat = paInt16; inParams.sampleFormat = paInt16;
break; break;
case 4: case DevFmtFloat:
inParams.sampleFormat = paFloat32; inParams.sampleFormat = paFloat32;
break; break;
default: case DevFmtUShort:
AL_PRINT("Unknown format: 0x%x\n", device->Format); AL_PRINT("Unsigned short not supported\n");
goto error; goto error;
} }
inParams.channelCount = aluChannelsFromFormat(device->Format); inParams.channelCount = ChannelsFromDevFmt(device->FmtChans);
err = pPa_OpenStream(&data->stream, &inParams, NULL, device->Frequency, err = pPa_OpenStream(&data->stream, &inParams, NULL, device->Frequency,
paFramesPerBufferUnspecified, paNoFlag, pa_capture_cb, device); paFramesPerBufferUnspecified, paNoFlag, pa_capture_cb, device);

55
Alc/pulseaudio.c
View File

@ -385,17 +385,17 @@ static void sink_info_callback(pa_context *context, const pa_sink_info *info, in
char chanmap_str[256] = ""; char chanmap_str[256] = "";
const struct { const struct {
const char *str; const char *str;
ALenum format; enum DevFmtChannels chans;
} chanmaps[] = { } chanmaps[] = {
{ "front-left,front-right,front-center,lfe,rear-left,rear-right,side-left,side-right", { "front-left,front-right,front-center,lfe,rear-left,rear-right,side-left,side-right",
AL_FORMAT_71CHN32 }, DevFmtX71 },
{ "front-left,front-right,front-center,lfe,rear-center,side-left,side-right", { "front-left,front-right,front-center,lfe,rear-center,side-left,side-right",
AL_FORMAT_61CHN32 }, DevFmtX61 },
{ "front-left,front-right,front-center,lfe,rear-left,rear-right", { "front-left,front-right,front-center,lfe,rear-left,rear-right",
AL_FORMAT_51CHN32 }, DevFmtX51 },
{ "front-left,front-right,rear-left,rear-right", AL_FORMAT_QUAD32 }, { "front-left,front-right,rear-left,rear-right", DevFmtQuad },
{ "front-left,front-right", AL_FORMAT_STEREO_FLOAT32 }, { "front-left,front-right", DevFmtStereo },
{ "mono", AL_FORMAT_MONO_FLOAT32 }, { "mono", DevFmtMono },
{ NULL, 0 } { NULL, 0 }
}; };
int i; int i;
@ -420,7 +420,7 @@ static void sink_info_callback(pa_context *context, const pa_sink_info *info, in
#endif #endif
) )
{ {
device->Format = chanmaps[i].format; device->FmtChans = chanmaps[i].chans;
return; return;
} }
} }
@ -878,7 +878,7 @@ static ALCboolean pulse_reset_playback(ALCdevice *device) //{{{
if(!ConfigValueExists(NULL, "frequency")) if(!ConfigValueExists(NULL, "frequency"))
flags |= PA_STREAM_FIX_RATE; flags |= PA_STREAM_FIX_RATE;
data->frame_size = aluFrameSizeFromFormat(device->Format); data->frame_size = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
data->attr.prebuf = -1; data->attr.prebuf = -1;
data->attr.fragsize = -1; data->attr.fragsize = -1;
data->attr.minreq = device->UpdateSize * data->frame_size; data->attr.minreq = device->UpdateSize * data->frame_size;
@ -889,24 +889,26 @@ static ALCboolean pulse_reset_playback(ALCdevice *device) //{{{
flags |= PA_STREAM_EARLY_REQUESTS; flags |= PA_STREAM_EARLY_REQUESTS;
flags |= PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE; flags |= PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE;
switch(aluBytesFromFormat(device->Format)) switch(device->FmtType)
{ {
case 1: case DevFmtByte:
device->FmtType = DevFmtUByte;
/* fall-through */
case DevFmtUByte:
data->spec.format = PA_SAMPLE_U8; data->spec.format = PA_SAMPLE_U8;
break; break;
case 2: case DevFmtUShort:
device->FmtType = DevFmtShort;
/* fall-through */
case DevFmtShort:
data->spec.format = PA_SAMPLE_S16NE; data->spec.format = PA_SAMPLE_S16NE;
break; break;
case 4: case DevFmtFloat:
data->spec.format = PA_SAMPLE_FLOAT32NE; data->spec.format = PA_SAMPLE_FLOAT32NE;
break; break;
default:
AL_PRINT("Unknown format: 0x%x\n", device->Format);
ppa_threaded_mainloop_unlock(data->loop);
return ALC_FALSE;
} }
data->spec.rate = device->Frequency; data->spec.rate = device->Frequency;
data->spec.channels = aluChannelsFromFormat(device->Format); data->spec.channels = ChannelsFromDevFmt(device->FmtChans);
if(ppa_sample_spec_valid(&data->spec) == 0) if(ppa_sample_spec_valid(&data->spec) == 0)
{ {
@ -1056,7 +1058,7 @@ static ALCboolean pulse_open_capture(ALCdevice *device, const ALCchar *device_na
ppa_threaded_mainloop_lock(data->loop); ppa_threaded_mainloop_lock(data->loop);
data->samples = device->UpdateSize * device->NumUpdates; data->samples = device->UpdateSize * device->NumUpdates;
data->frame_size = aluFrameSizeFromFormat(device->Format); data->frame_size = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
if(data->samples < 100 * device->Frequency / 1000) if(data->samples < 100 * device->Frequency / 1000)
data->samples = 100 * device->Frequency / 1000; data->samples = 100 * device->Frequency / 1000;
@ -1074,21 +1076,22 @@ static ALCboolean pulse_open_capture(ALCdevice *device, const ALCchar *device_na
data->frame_size; data->frame_size;
data->spec.rate = device->Frequency; data->spec.rate = device->Frequency;
data->spec.channels = aluChannelsFromFormat(device->Format); data->spec.channels = ChannelsFromDevFmt(device->FmtChans);
switch(aluBytesFromFormat(device->Format)) switch(device->FmtType)
{ {
case 1: case DevFmtUByte:
data->spec.format = PA_SAMPLE_U8; data->spec.format = PA_SAMPLE_U8;
break; break;
case 2: case DevFmtShort:
data->spec.format = PA_SAMPLE_S16NE; data->spec.format = PA_SAMPLE_S16NE;
break; break;
case 4: case DevFmtFloat:
data->spec.format = PA_SAMPLE_FLOAT32NE; data->spec.format = PA_SAMPLE_FLOAT32NE;
break; break;
default: case DevFmtByte:
AL_PRINT("Unknown format: 0x%x\n", device->Format); case DevFmtUShort:
AL_PRINT("Capture format type %#x capture not supported on PulseAudio\n", device->FmtType);
ppa_threaded_mainloop_unlock(data->loop); ppa_threaded_mainloop_unlock(data->loop);
goto fail; goto fail;
} }

41
Alc/solaris.c
View File

@ -59,7 +59,7 @@ static ALuint SolarisProc(ALvoid *ptr)
SetRTPriority(); SetRTPriority();
frameSize = aluFrameSizeFromFormat(pDevice->Format); frameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
while(!data->killNow && pDevice->Connected) while(!data->killNow && pDevice->Connected)
{ {
@ -139,37 +139,30 @@ static ALCboolean solaris_reset_playback(ALCdevice *device)
AUDIO_INITINFO(&info); AUDIO_INITINFO(&info);
switch(aluBytesFromFormat(device->Format)) switch(device->FmtType)
{ {
case 1: case DevFmtByte:
device->FmtType = DevFmtUByte;
/* fall-through */
case DevFmtUByte:
info.play.precision = 8; info.play.precision = 8;
info.play.encoding = AUDIO_ENCODING_LINEAR8; info.play.encoding = AUDIO_ENCODING_LINEAR8;
break; break;
case 4: case DevFmtUShort:
switch(numChannels) case DevFmtFloat:
{ device->FmtType = DevFmtShort;
case 1: device->Format = AL_FORMAT_MONO16; break;
case 2: device->Format = AL_FORMAT_STEREO16; break;
case 4: device->Format = AL_FORMAT_QUAD16; break;
case 6: device->Format = AL_FORMAT_51CHN16; break;
case 7: device->Format = AL_FORMAT_61CHN16; break;
case 8: device->Format = AL_FORMAT_71CHN16; break;
}
/* fall-through */ /* fall-through */
case 2: case DevFmtShort:
info.play.precision = 16; info.play.precision = 16;
info.play.encoding = AUDIO_ENCODING_LINEAR; info.play.encoding = AUDIO_ENCODING_LINEAR;
break; break;
default:
AL_PRINT("Unknown format: 0x%x\n", device->Format);
return ALC_FALSE;
} }
numChannels = aluChannelsFromFormat(device->Format); numChannels = ChannelsFromDevFmt(device->FmtChans);
info.play.sample_rate = device->Frequency; info.play.sample_rate = device->Frequency;
info.play.channels = numChannels; info.play.channels = numChannels;
frameSize = numChannels * aluBytesFromFormat(device->Format); frameSize = numChannels * BytesFromDevFmt(device->FmtType);
info.play.buffer_size = device->UpdateSize*device->NumUpdates * frameSize; info.play.buffer_size = device->UpdateSize*device->NumUpdates * frameSize;
if(ioctl(data->fd, AUDIO_SETINFO, &info) < 0) if(ioctl(data->fd, AUDIO_SETINFO, &info) < 0)
@ -178,16 +171,16 @@ static ALCboolean solaris_reset_playback(ALCdevice *device)
return ALC_FALSE; return ALC_FALSE;
} }
if(aluChannelsFromFormat(device->Format) != info.play.channels) if(ChannelsFromDevFmt(device->FmtChans) != info.play.channels)
{ {
AL_PRINT("Could not set %d channels, got %d instead\n", aluChannelsFromFormat(device->Format), info.play.channels); AL_PRINT("Could not set %d channels, got %d instead\n", ChannelsFromDevFmt(device->FmtChans), info.play.channels);
return ALC_FALSE; return ALC_FALSE;
} }
if(!((info.play.precision == 8 && aluBytesFromFormat(device->Format) == 1) || if(!((info.play.precision == 8 && device->FmtType == DevFmtUByte) ||
(info.play.precision == 16 && aluBytesFromFormat(device->Format) == 2))) (info.play.precision == 16 && device->FmtType == DevFmtShort)))
{ {
AL_PRINT("Could not set %d-bit output, got %d\n", aluBytesFromFormat(device->Format)*8, info.play.precision); AL_PRINT("Could not set %#x sample type, got %d\n", device->FmtType, info.play.precision);
return ALC_FALSE; return ALC_FALSE;
} }

39
Alc/wave.c
View File

@ -95,7 +95,7 @@ static ALuint WaveProc(ALvoid *ptr)
pDevice->Frequency / 2; pDevice->Frequency / 2;
uSB.s = 1; uSB.s = 1;
frameSize = aluFrameSizeFromFormat(pDevice->Format); frameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
done = 0; done = 0;
start = timeGetTime(); start = timeGetTime();
@ -124,20 +124,21 @@ static ALuint WaveProc(ALvoid *ptr)
if(uSB.b[0] != 1) if(uSB.b[0] != 1)
{ {
ALuint bytesize = BytesFromDevFmt(pDevice->FmtType);
ALubyte *bytes = data->buffer; ALubyte *bytes = data->buffer;
ALuint i; ALuint i;
if(aluBytesFromFormat(pDevice->Format) == 1) if(bytesize == 1)
{ {
for(i = 0;i < data->size;i++) for(i = 0;i < data->size;i++)
fputc(bytes[i], data->f); fputc(bytes[i], data->f);
} }
else if(aluBytesFromFormat(pDevice->Format) == 2) else if(bytesize == 2)
{ {
for(i = 0;i < data->size;i++) for(i = 0;i < data->size;i++)
fputc(bytes[i^1], data->f); fputc(bytes[i^1], data->f);
} }
else if(aluBytesFromFormat(pDevice->Format) == 4) else if(bytesize == 4)
{ {
for(i = 0;i < data->size;i++) for(i = 0;i < data->size;i++)
fputc(bytes[i^3], data->f); fputc(bytes[i^3], data->f);
@ -199,29 +200,27 @@ static void wave_close_playback(ALCdevice *device)
static ALCboolean wave_reset_playback(ALCdevice *device) static ALCboolean wave_reset_playback(ALCdevice *device)
{ {
wave_data *data = (wave_data*)device->ExtraData; wave_data *data = (wave_data*)device->ExtraData;
ALuint channels, bits; ALuint channels=0, bits=0;
size_t val; size_t val;
fseek(data->f, 0, SEEK_SET); fseek(data->f, 0, SEEK_SET);
clearerr(data->f); clearerr(data->f);
bits = aluBytesFromFormat(device->Format) * 8; switch(device->FmtType)
channels = aluChannelsFromFormat(device->Format);
/* 7.1 max */
if(channels > 8)
{ {
if(bits == 8) case DevFmtByte:
device->Format = AL_FORMAT_71CHN8; device->FmtType = DevFmtUByte;
else if(bits == 16) break;
device->Format = AL_FORMAT_71CHN16; case DevFmtUShort:
else device->FmtType = DevFmtShort;
{ break;
device->Format = AL_FORMAT_71CHN32; case DevFmtUByte:
bits = 32; case DevFmtShort:
} case DevFmtFloat:
channels = 8; break;
} }
bits = BytesFromDevFmt(device->FmtType) * 8;
channels = ChannelsFromDevFmt(device->FmtChans);
fprintf(data->f, "RIFF"); fprintf(data->f, "RIFF");
fwrite32le(0xFFFFFFFF, data->f); // 'RIFF' header len; filled in at close fwrite32le(0xFFFFFFFF, data->f); // 'RIFF' header len; filled in at close

46
Alc/winmm.c
View File

@ -194,7 +194,7 @@ static DWORD WINAPI PlaybackThreadProc(LPVOID lpParameter)
ALuint FrameSize; ALuint FrameSize;
MSG msg; MSG msg;
FrameSize = aluFrameSizeFromFormat(pDevice->Format); FrameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
while(GetMessage(&msg, NULL, 0, 0)) while(GetMessage(&msg, NULL, 0, 0))
{ {
@ -272,7 +272,7 @@ static DWORD WINAPI CaptureThreadProc(LPVOID lpParameter)
ALuint FrameSize; ALuint FrameSize;
MSG msg; MSG msg;
FrameSize = aluFrameSizeFromFormat(pDevice->Format); FrameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
while(GetMessage(&msg, NULL, 0, 0)) while(GetMessage(&msg, NULL, 0, 0))
{ {
@ -336,25 +336,26 @@ static ALCboolean WinMMOpenPlayback(ALCdevice *pDevice, const ALCchar *deviceNam
} }
pDevice->ExtraData = pData; pDevice->ExtraData = pData;
if(aluChannelsFromFormat(pDevice->Format) >= 2) if(pDevice->FmtChans != DevFmtMono)
pDevice->FmtChans = DevFmtStereo;
switch(pDevice->FmtType)
{ {
if(aluBytesFromFormat(pDevice->Format) >= 2) case DevFmtByte:
pDevice->Format = AL_FORMAT_STEREO16; pDevice->FmtType = DevFmtUByte;
else break;
pDevice->Format = AL_FORMAT_STEREO8; case DevFmtUShort:
} case DevFmtFloat:
else pDevice->FmtType = DevFmtShort;
{ break;
if(aluBytesFromFormat(pDevice->Format) >= 2) case DevFmtUByte:
pDevice->Format = AL_FORMAT_MONO16; case DevFmtShort:
else break;
pDevice->Format = AL_FORMAT_MONO8;
} }
memset(&wfexFormat, 0, sizeof(WAVEFORMATEX)); memset(&wfexFormat, 0, sizeof(WAVEFORMATEX));
wfexFormat.wFormatTag = WAVE_FORMAT_PCM; wfexFormat.wFormatTag = WAVE_FORMAT_PCM;
wfexFormat.nChannels = aluChannelsFromFormat(pDevice->Format); wfexFormat.nChannels = ChannelsFromDevFmt(pDevice->FmtChans);
wfexFormat.wBitsPerSample = aluBytesFromFormat(pDevice->Format) * 8; wfexFormat.wBitsPerSample = BytesFromDevFmt(pDevice->FmtType) * 8;
wfexFormat.nBlockAlign = wfexFormat.wBitsPerSample * wfexFormat.nBlockAlign = wfexFormat.wBitsPerSample *
wfexFormat.nChannels / 8; wfexFormat.nChannels / 8;
wfexFormat.nSamplesPerSec = pDevice->Frequency; wfexFormat.nSamplesPerSec = pDevice->Frequency;
@ -433,7 +434,7 @@ static ALCboolean WinMMResetPlayback(ALCdevice *device)
// Create 4 Buffers // Create 4 Buffers
lBufferSize = device->UpdateSize*device->NumUpdates / 4; lBufferSize = device->UpdateSize*device->NumUpdates / 4;
lBufferSize *= aluFrameSizeFromFormat(device->Format); lBufferSize *= FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
BufferData = calloc(4, lBufferSize); BufferData = calloc(4, lBufferSize);
for(i = 0;i < 4;i++) for(i = 0;i < 4;i++)
@ -533,10 +534,17 @@ static ALCboolean WinMMOpenCapture(ALCdevice *pDevice, const ALCchar *deviceName
} }
pDevice->ExtraData = pData; pDevice->ExtraData = pData;
if((pDevice->FmtChans != DevFmtMono && pDevice->FmtChans != DevFmtStereo) ||
(pDevice->FmtType != DevFmtUByte && pDevice->FmtType != DevFmtShort))
{
alcSetError(pDevice, ALC_INVALID_ENUM);
goto failure;
}
memset(&wfexCaptureFormat, 0, sizeof(WAVEFORMATEX)); memset(&wfexCaptureFormat, 0, sizeof(WAVEFORMATEX));
wfexCaptureFormat.wFormatTag = WAVE_FORMAT_PCM; wfexCaptureFormat.wFormatTag = WAVE_FORMAT_PCM;
wfexCaptureFormat.nChannels = aluChannelsFromFormat(pDevice->Format); wfexCaptureFormat.nChannels = ChannelsFromDevFmt(pDevice->FmtChans);
wfexCaptureFormat.wBitsPerSample = aluBytesFromFormat(pDevice->Format) * 8; wfexCaptureFormat.wBitsPerSample = BytesFromDevFmt(pDevice->FmtType) * 8;
wfexCaptureFormat.nBlockAlign = wfexCaptureFormat.wBitsPerSample * wfexCaptureFormat.nBlockAlign = wfexCaptureFormat.wBitsPerSample *
wfexCaptureFormat.nChannels / 8; wfexCaptureFormat.nChannels / 8;
wfexCaptureFormat.nSamplesPerSec = pDevice->Frequency; wfexCaptureFormat.nSamplesPerSec = pDevice->Frequency;

28
OpenAL32/Include/alMain.h
View File

@ -316,6 +316,31 @@ ALenum InsertUIntMapEntry(UIntMap *map, ALuint key, ALvoid *value);
void RemoveUIntMapKey(UIntMap *map, ALuint key); void RemoveUIntMapKey(UIntMap *map, ALuint key);
ALvoid *LookupUIntMapKey(UIntMap *map, ALuint key); ALvoid *LookupUIntMapKey(UIntMap *map, ALuint key);
/* Device formats */
enum DevFmtType {
DevFmtByte, /* AL_BYTE */
DevFmtUByte, /* AL_UNSIGNED_BYTE */
DevFmtShort, /* AL_SHORT */
DevFmtUShort, /* AL_UNSIGNED_SHORT */
DevFmtFloat, /* AL_FLOAT */
};
enum DevFmtChannels {
DevFmtMono, /* AL_MONO */
DevFmtStereo, /* AL_STEREO */
DevFmtQuad, /* AL_QUAD */
DevFmtX51, /* AL_5POINT1 */
DevFmtX61, /* AL_6POINT1 */
DevFmtX71, /* AL_7POINT1 */
};
ALuint BytesFromDevFmt(enum DevFmtType type);
ALuint ChannelsFromDevFmt(enum DevFmtChannels chans);
static __inline ALuint FrameSizeFromDevFmt(enum DevFmtChannels chans,
enum DevFmtType type)
{
return ChannelsFromDevFmt(chans) * BytesFromDevFmt(type);
}
struct ALCdevice_struct struct ALCdevice_struct
{ {
@ -325,7 +350,8 @@ struct ALCdevice_struct
ALuint Frequency; ALuint Frequency;
ALuint UpdateSize; ALuint UpdateSize;
ALuint NumUpdates; ALuint NumUpdates;
ALenum Format; enum DevFmtChannels FmtChans;
enum DevFmtType FmtType;
ALCchar *szDeviceName; ALCchar *szDeviceName;