AuroraMiddleware/AuroraOpenALSoft
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Combine related members into a struct

Browse Source
This commit is contained in:
Chris Robinson 2016-08-24 00:25:28 -07:00
parent e77de8b12a
commit 8bf4a22876
6 changed files with 86 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
Alc/ALc.c
View File

@ -1923,7 +1923,7 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
/*************************************************************************
* Update device format request if HRTF is requested
*/
device->Hrtf_Status = ALC_HRTF_DISABLED_SOFT;
device->Hrtf.Status = ALC_HRTF_DISABLED_SOFT;
if(device->Type != Loopback)
{
const char *hrtf;
@ -1939,31 +1939,31 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
if(hrtf_userreq == Hrtf_Enable || (hrtf_userreq != Hrtf_Disable && hrtf_appreq == Hrtf_Enable))
{
if(VECTOR_SIZE(device->Hrtf_List) == 0)
if(VECTOR_SIZE(device->Hrtf.List) == 0)
{
VECTOR_DEINIT(device->Hrtf_List);
device->Hrtf_List = EnumerateHrtf(device->DeviceName);
VECTOR_DEINIT(device->Hrtf.List);
device->Hrtf.List = EnumerateHrtf(device->DeviceName);
}
if(VECTOR_SIZE(device->Hrtf_List) > 0)
if(VECTOR_SIZE(device->Hrtf.List) > 0)
{
device->FmtChans = DevFmtStereo;
if(hrtf_id >= 0 && (size_t)hrtf_id < VECTOR_SIZE(device->Hrtf_List))
device->Frequency = VECTOR_ELEM(device->Hrtf_List, hrtf_id).hrtf->sampleRate;
if(hrtf_id >= 0 && (size_t)hrtf_id < VECTOR_SIZE(device->Hrtf.List))
device->Frequency = VECTOR_ELEM(device->Hrtf.List, hrtf_id).hrtf->sampleRate;
else
device->Frequency = VECTOR_ELEM(device->Hrtf_List, 0).hrtf->sampleRate;
device->Frequency = VECTOR_ELEM(device->Hrtf.List, 0).hrtf->sampleRate;
device->Flags |= DEVICE_CHANNELS_REQUEST | DEVICE_FREQUENCY_REQUEST;
}
else
{
hrtf_userreq = Hrtf_Default;
hrtf_appreq = Hrtf_Disable;
device->Hrtf_Status = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
device->Hrtf.Status = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
}
}
}
else if(hrtf_appreq == Hrtf_Enable)
{
size_t i = VECTOR_SIZE(device->Hrtf_List);
size_t i = VECTOR_SIZE(device->Hrtf.List);
/* Loopback device. We don't need to match to a specific HRTF entry
* here. If the requested ID matches, we'll pick that later, if not,
* we'll try to auto-select one anyway. Just make sure one exists
@ -1971,24 +1971,24 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
*/
if(device->FmtChans == DevFmtStereo)
{
if(VECTOR_SIZE(device->Hrtf_List) == 0)
if(VECTOR_SIZE(device->Hrtf.List) == 0)
{
VECTOR_DEINIT(device->Hrtf_List);
device->Hrtf_List = EnumerateHrtf(device->DeviceName);
VECTOR_DEINIT(device->Hrtf.List);
device->Hrtf.List = EnumerateHrtf(device->DeviceName);
}
for(i = 0;i < VECTOR_SIZE(device->Hrtf_List);i++)
for(i = 0;i < VECTOR_SIZE(device->Hrtf.List);i++)
{
const struct Hrtf *hrtf = VECTOR_ELEM(device->Hrtf_List, i).hrtf;
const struct Hrtf *hrtf = VECTOR_ELEM(device->Hrtf.List, i).hrtf;
if(hrtf->sampleRate == device->Frequency)
break;
}
}
if(i == VECTOR_SIZE(device->Hrtf_List))
if(i == VECTOR_SIZE(device->Hrtf.List))
{
ERR("Requested format not HRTF compatible: %s, %uhz\n",
DevFmtChannelsString(device->FmtChans), device->Frequency);
hrtf_appreq = Hrtf_Disable;
device->Hrtf_Status = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
device->Hrtf.Status = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
}
}
@ -2043,7 +2043,7 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
size = device->Dry.NumChannels * sizeof(device->Dry.Buffer[0]);
if((device->AmbiDecoder && bformatdec_getOrder(device->AmbiDecoder) >= 2))
size += (ChannelsFromDevFmt(device->FmtChans)+4) * sizeof(device->Dry.Buffer[0]);
else if(device->Hrtf || device->Uhj_Encoder || device->AmbiDecoder)
else if(device->Hrtf.Handle || device->Uhj_Encoder || device->AmbiDecoder)
size += ChannelsFromDevFmt(device->FmtChans) * sizeof(device->Dry.Buffer[0]);
else if(device->FmtChans > DevFmtAmbi1 && device->FmtChans <= DevFmtAmbi3)
size += 4 * sizeof(device->Dry.Buffer[0]);
@ -2054,7 +2054,7 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
return ALC_INVALID_DEVICE;
}
if(device->Hrtf || device->Uhj_Encoder || device->AmbiDecoder)
if(device->Hrtf.Handle || device->Uhj_Encoder || device->AmbiDecoder)
{
device->RealOut.Buffer = device->Dry.Buffer + device->Dry.NumChannels;
device->RealOut.NumChannels = ChannelsFromDevFmt(device->FmtChans);
@ -2204,8 +2204,8 @@ static ALCvoid FreeDevice(ALCdevice *device)
}
ResetUIntMap(&device->FilterMap);
AL_STRING_DEINIT(device->Hrtf_Name);
FreeHrtfList(&device->Hrtf_List);
AL_STRING_DEINIT(device->Hrtf.Name);
FreeHrtfList(&device->Hrtf.List);
al_free(device->Bs2b);
device->Bs2b = NULL;
@ -2683,7 +2683,7 @@ ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *Device, ALCenum para
else
{
almtx_lock(&Device->BackendLock);
value = (Device->Hrtf ? al_string_get_cstr(Device->Hrtf_Name) : "");
value = (Device->Hrtf.Handle ? al_string_get_cstr(Device->Hrtf.Name) : "");
almtx_unlock(&Device->BackendLock);
ALCdevice_DecRef(Device);
}
@ -2824,10 +2824,10 @@ static ALCsizei GetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALC
values[i++] = device->NumAuxSends;
values[i++] = ALC_HRTF_SOFT;
values[i++] = (device->Hrtf ? ALC_TRUE : ALC_FALSE);
values[i++] = (device->Hrtf.Handle ? ALC_TRUE : ALC_FALSE);
values[i++] = ALC_HRTF_STATUS_SOFT;
values[i++] = device->Hrtf_Status;
values[i++] = device->Hrtf.Status;
almtx_unlock(&device->BackendLock);
values[i++] = 0;
@ -2892,18 +2892,18 @@ static ALCsizei GetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALC
return 1;
case ALC_HRTF_SOFT:
values[0] = (device->Hrtf ? ALC_TRUE : ALC_FALSE);
values[0] = (device->Hrtf.Handle ? ALC_TRUE : ALC_FALSE);
return 1;
case ALC_HRTF_STATUS_SOFT:
values[0] = device->Hrtf_Status;
values[0] = device->Hrtf.Status;
return 1;
case ALC_NUM_HRTF_SPECIFIERS_SOFT:
almtx_lock(&device->BackendLock);
FreeHrtfList(&device->Hrtf_List);
device->Hrtf_List = EnumerateHrtf(device->DeviceName);
values[0] = (ALCint)VECTOR_SIZE(device->Hrtf_List);
FreeHrtfList(&device->Hrtf.List);
device->Hrtf.List = EnumerateHrtf(device->DeviceName);
values[0] = (ALCint)VECTOR_SIZE(device->Hrtf.List);
almtx_unlock(&device->BackendLock);
return 1;
@ -2994,10 +2994,10 @@ ALC_API void ALC_APIENTRY alcGetInteger64vSOFT(ALCdevice *device, ALCenum pname,
values[i++] = device->NumAuxSends;
values[i++] = ALC_HRTF_SOFT;
values[i++] = (device->Hrtf ? ALC_TRUE : ALC_FALSE);
values[i++] = (device->Hrtf.Handle ? ALC_TRUE : ALC_FALSE);
values[i++] = ALC_HRTF_STATUS_SOFT;
values[i++] = device->Hrtf_Status;
values[i++] = device->Hrtf.Status;
clock = V0(device->Backend,getClockLatency)();
values[i++] = ALC_DEVICE_CLOCK_SOFT;
@ -3403,8 +3403,8 @@ ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)
device->Flags = 0;
device->Bs2b = NULL;
device->Uhj_Encoder = NULL;
VECTOR_INIT(device->Hrtf_List);
AL_STRING_INIT(device->Hrtf_Name);
VECTOR_INIT(device->Hrtf.List);
AL_STRING_INIT(device->Hrtf.Name);
device->Render_Mode = NormalRender;
AL_STRING_INIT(device->DeviceName);
device->Dry.Buffer = NULL;
@ -3683,8 +3683,8 @@ ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName,
device->Connected = ALC_TRUE;
device->Type = Capture;
VECTOR_INIT(device->Hrtf_List);
AL_STRING_INIT(device->Hrtf_Name);
VECTOR_INIT(device->Hrtf.List);
AL_STRING_INIT(device->Hrtf.Name);
AL_STRING_INIT(device->DeviceName);
device->Dry.Buffer = NULL;
@ -3878,8 +3878,8 @@ ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceN
ATOMIC_INIT(&device->LastError, ALC_NO_ERROR);
device->Flags = 0;
VECTOR_INIT(device->Hrtf_List);
AL_STRING_INIT(device->Hrtf_Name);
VECTOR_INIT(device->Hrtf.List);
AL_STRING_INIT(device->Hrtf.Name);
device->Bs2b = NULL;
device->Uhj_Encoder = NULL;
device->Render_Mode = NormalRender;
@ -4065,8 +4065,8 @@ ALC_API const ALCchar* ALC_APIENTRY alcGetStringiSOFT(ALCdevice *device, ALCenum
else switch(paramName)
{
case ALC_HRTF_SPECIFIER_SOFT:
if(index >= 0 && (size_t)index < VECTOR_SIZE(device->Hrtf_List))
str = al_string_get_cstr(VECTOR_ELEM(device->Hrtf_List, index).name);
if(index >= 0 && (size_t)index < VECTOR_SIZE(device->Hrtf.List))
str = al_string_get_cstr(VECTOR_ELEM(device->Hrtf.List, index).name);
else
alcSetError(device, ALC_INVALID_VALUE);
break;

14
Alc/ALu.c
View File

@ -649,7 +649,7 @@ static void CalcNonAttnSourceParams(ALvoice *voice, const struct ALsourceProps *
}
/* Get the static HRIR coefficients and delays for this channel. */
GetLerpedHrtfCoeffs(Device->Hrtf,
GetLerpedHrtfCoeffs(Device->Hrtf.Handle,
chans[c].elevation, chans[c].angle, 0.0f, DryGain,
voice->Chan[c].Direct.Hrtf.Target.Coeffs,
voice->Chan[c].Direct.Hrtf.Target.Delay
@ -1165,7 +1165,7 @@ static void CalcAttnSourceParams(ALvoice *voice, const struct ALsourceProps *pro
spread = asinf(radius / Distance) * 2.0f;
/* Get the HRIR coefficients and delays. */
GetLerpedHrtfCoeffs(Device->Hrtf, ev, az, spread, DryGain,
GetLerpedHrtfCoeffs(Device->Hrtf.Handle, ev, az, spread, DryGain,
voice->Chan[0].Direct.Hrtf.Target.Coeffs,
voice->Chan[0].Direct.Hrtf.Target.Delay);
@ -1526,23 +1526,23 @@ ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
V0(device->Backend,unlock)();
IncrementRef(&device->MixCount);
if(device->Hrtf)
if(device->Hrtf.Handle)
{
int lidx = GetChannelIdxByName(device->RealOut, FrontLeft);
int ridx = GetChannelIdxByName(device->RealOut, FrontRight);
if(lidx != -1 && ridx != -1)
{
HrtfDirectMixerFunc HrtfMix = SelectHrtfMixer();
ALuint irsize = device->Hrtf_IrSize;
ALuint irsize = device->Hrtf.IrSize;
for(c = 0;c < device->Dry.NumChannels;c++)
{
HrtfMix(device->RealOut.Buffer, lidx, ridx,
device->Dry.Buffer[c], device->Hrtf_Offset, irsize,
device->Hrtf_Coeffs[c], device->Hrtf_Values[c],
device->Dry.Buffer[c], device->Hrtf.Offset, irsize,
device->Hrtf.Coeffs[c], device->Hrtf.Values[c],
SamplesToDo
);
}
device->Hrtf_Offset += SamplesToDo;
device->Hrtf.Offset += SamplesToDo;
}
}
else if(device->AmbiDecoder)

4
Alc/effects/reverb.c
View File

@ -391,7 +391,7 @@ static ALboolean ALreverbState_deviceUpdate(ALreverbState *State, ALCdevice *Dev
return AL_FALSE;
/* HRTF and UHJ will mix to the real output for ambient output. */
if(Device->Hrtf || Device->Uhj_Encoder)
if(Device->Hrtf.Handle || Device->Uhj_Encoder)
{
State->ExtraOut = Device->RealOut.Buffer;
State->ExtraChannels = Device->RealOut.NumChannels;
@ -956,7 +956,7 @@ static ALvoid ALreverbState_update(ALreverbState *State, const ALCdevice *Device
gain = props->Reverb.Gain * Slot->Params.Gain * ReverbBoost;
// Update early and late 3D panning.
if(Device->Hrtf || Device->Uhj_Encoder)
if(Device->Hrtf.Handle || Device->Uhj_Encoder)
UpdateMixedPanning(Device, props->Reverb.ReflectionsPan,
props->Reverb.LateReverbPan, gain,
props->Reverb.ReflectionsGain,

2
Alc/mixer.c
View File

@ -393,7 +393,7 @@ ALvoid MixSource(ALvoice *voice, ALsource *Source, ALCdevice *Device, ALuint Sam
SampleSize = Source->SampleSize;
increment = voice->Step;
IrSize = (Device->Hrtf ? Device->Hrtf->irSize : 0);
IrSize = (Device->Hrtf.Handle ? Device->Hrtf.Handle->irSize : 0);
Resample = ((increment == FRACTIONONE && DataPosFrac == 0) ?
Resample_copy32_C : ResampleSamples);

51
Alc/panning.c
View File

@ -772,12 +772,13 @@ static void InitHrtfPanning(ALCdevice *device)
device->FOAOut.Ambi = device->Dry.Ambi;
device->FOAOut.CoeffCount = device->Dry.CoeffCount;
memset(device->Hrtf_Coeffs, 0, sizeof(device->Hrtf_Coeffs));
device->Hrtf_IrSize = BuildBFormatHrtf(device->Hrtf, device->Hrtf_Coeffs,
device->Dry.NumChannels);
memset(device->Hrtf.Coeffs, 0, sizeof(device->Hrtf.Coeffs));
device->Hrtf.IrSize = BuildBFormatHrtf(device->Hrtf.Handle,
device->Hrtf.Coeffs, device->Dry.NumChannels
);
/* Round up to the nearest multiple of 8 */
device->Hrtf_IrSize = (device->Hrtf_IrSize+7)&~7;
device->Hrtf.IrSize = (device->Hrtf.IrSize+7)&~7;
}
static void InitUhjPanning(ALCdevice *device)
@ -805,8 +806,8 @@ void aluInitRenderer(ALCdevice *device, ALint hrtf_id, enum HrtfRequestMode hrtf
int bs2blevel;
size_t i;
device->Hrtf = NULL;
al_string_clear(&device->Hrtf_Name);
device->Hrtf.Handle = NULL;
al_string_clear(&device->Hrtf.Name);
device->Render_Mode = NormalRender;
memset(&device->Dry.Ambi, 0, sizeof(device->Dry.Ambi));
@ -820,7 +821,7 @@ void aluInitRenderer(ALCdevice *device, ALint hrtf_id, enum HrtfRequestMode hrtf
AmbDecConf conf, *pconf = NULL;
if(hrtf_appreq == Hrtf_Enable)
device->Hrtf_Status = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
device->Hrtf.Status = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
ambdec_init(&conf);
@ -920,48 +921,48 @@ void aluInitRenderer(ALCdevice *device, ALint hrtf_id, enum HrtfRequestMode hrtf
(hrtf_appreq == Hrtf_Enable);
if(!usehrtf) goto no_hrtf;
device->Hrtf_Status = ALC_HRTF_ENABLED_SOFT;
device->Hrtf.Status = ALC_HRTF_ENABLED_SOFT;
if(headphones && hrtf_appreq != Hrtf_Disable)
device->Hrtf_Status = ALC_HRTF_HEADPHONES_DETECTED_SOFT;
device->Hrtf.Status = ALC_HRTF_HEADPHONES_DETECTED_SOFT;
}
else
{
if(hrtf_userreq != Hrtf_Enable)
{
if(hrtf_appreq == Hrtf_Enable)
device->Hrtf_Status = ALC_HRTF_DENIED_SOFT;
device->Hrtf.Status = ALC_HRTF_DENIED_SOFT;
goto no_hrtf;
}
device->Hrtf_Status = ALC_HRTF_REQUIRED_SOFT;
device->Hrtf.Status = ALC_HRTF_REQUIRED_SOFT;
}
if(VECTOR_SIZE(device->Hrtf_List) == 0)
if(VECTOR_SIZE(device->Hrtf.List) == 0)
{
VECTOR_DEINIT(device->Hrtf_List);
device->Hrtf_List = EnumerateHrtf(device->DeviceName);
VECTOR_DEINIT(device->Hrtf.List);
device->Hrtf.List = EnumerateHrtf(device->DeviceName);
}
if(hrtf_id >= 0 && (size_t)hrtf_id < VECTOR_SIZE(device->Hrtf_List))
if(hrtf_id >= 0 && (size_t)hrtf_id < VECTOR_SIZE(device->Hrtf.List))
{
const HrtfEntry *entry = &VECTOR_ELEM(device->Hrtf_List, hrtf_id);
const HrtfEntry *entry = &VECTOR_ELEM(device->Hrtf.List, hrtf_id);
if(entry->hrtf->sampleRate == device->Frequency)
{
device->Hrtf = entry->hrtf;
al_string_copy(&device->Hrtf_Name, entry->name);
device->Hrtf.Handle = entry->hrtf;
al_string_copy(&device->Hrtf.Name, entry->name);
}
}
for(i = 0;!device->Hrtf && i < VECTOR_SIZE(device->Hrtf_List);i++)
for(i = 0;!device->Hrtf.Handle && i < VECTOR_SIZE(device->Hrtf.List);i++)
{
const HrtfEntry *entry = &VECTOR_ELEM(device->Hrtf_List, i);
const HrtfEntry *entry = &VECTOR_ELEM(device->Hrtf.List, i);
if(entry->hrtf->sampleRate == device->Frequency)
{
device->Hrtf = entry->hrtf;
al_string_copy(&device->Hrtf_Name, entry->name);
device->Hrtf.Handle = entry->hrtf;
al_string_copy(&device->Hrtf.Name, entry->name);
}
}
if(device->Hrtf)
if(device->Hrtf.Handle)
{
device->Render_Mode = HrtfRender;
if(ConfigValueStr(al_string_get_cstr(device->DeviceName), NULL, "hrtf-mode", &mode))
@ -974,11 +975,11 @@ void aluInitRenderer(ALCdevice *device, ALint hrtf_id, enum HrtfRequestMode hrtf
ERR("Unexpected hrtf-mode: %s\n", mode);
}
TRACE("HRTF enabled, \"%s\"\n", al_string_get_cstr(device->Hrtf_Name));
TRACE("HRTF enabled, \"%s\"\n", al_string_get_cstr(device->Hrtf.Name));
InitHrtfPanning(device);
return;
}
device->Hrtf_Status = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
device->Hrtf.Status = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
no_hrtf:
TRACE("HRTF disabled\n");

20
OpenAL32/Include/alMain.h
View File

@ -593,16 +593,18 @@ struct ALCdevice_struct
UIntMap FilterMap;
/* HRTF filter tables */
vector_HrtfEntry Hrtf_List;
al_string Hrtf_Name;
const struct Hrtf *Hrtf;
ALCenum Hrtf_Status;
struct {
vector_HrtfEntry List;
al_string Name;
ALCenum Status;
const struct Hrtf *Handle;
/* HRTF filter state for dry buffer content */
alignas(16) ALfloat Hrtf_Values[4][HRIR_LENGTH][2];
alignas(16) ALfloat Hrtf_Coeffs[4][HRIR_LENGTH][2];
ALuint Hrtf_Offset;
ALuint Hrtf_IrSize;
/* HRTF filter state for dry buffer content */
alignas(16) ALfloat Values[4][HRIR_LENGTH][2];
alignas(16) ALfloat Coeffs[4][HRIR_LENGTH][2];
ALuint Offset;
ALuint IrSize;
} Hrtf;
/* UHJ encoder state */
struct Uhj2Encoder *Uhj_Encoder;