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

Avoid ALfloat in some places

master
Chris Robinson 2020-04-08 06:17:04 -07:00
parent 024112a53a
commit 55539787fb
4 changed files with 90 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
alc/alc.cpp
View File

@ -1311,13 +1311,13 @@ ALuint BytesFromDevFmt(DevFmtType type) noexcept
{
switch(type)
{
case DevFmtByte: return sizeof(ALbyte);
case DevFmtUByte: return sizeof(ALubyte);
case DevFmtShort: return sizeof(ALshort);
case DevFmtUShort: return sizeof(ALushort);
case DevFmtInt: return sizeof(ALint);
case DevFmtUInt: return sizeof(ALuint);
case DevFmtFloat: return sizeof(ALfloat);
case DevFmtByte: return sizeof(ALCbyte);
case DevFmtUByte: return sizeof(ALCubyte);
case DevFmtShort: return sizeof(ALCshort);
case DevFmtUShort: return sizeof(ALCushort);
case DevFmtInt: return sizeof(ALCint);
case DevFmtUInt: return sizeof(ALCuint);
case DevFmtFloat: return sizeof(ALCfloat);
}
return 0;
}
@ -2099,7 +2099,7 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
/* Initialize band-splitting filters for the front-left and front-
* right channels, with a crossover at 5khz (could be higher).
*/
const ALfloat scale{5000.0f / static_cast<ALfloat>(device->Frequency)};
const float scale{5000.0f / static_cast<float>(device->Frequency)};
stablizer->LFilter.init(scale);
stablizer->RFilter = stablizer->LFilter;
@ -2147,7 +2147,7 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
if(depth > 0)
{
depth = clampi(depth, 2, 24);
device->DitherDepth = std::pow(2.0f, static_cast<ALfloat>(depth-1));
device->DitherDepth = std::pow(2.0f, static_cast<float>(depth-1));
}
}
if(!(device->DitherDepth > 0.0f))
@ -2186,7 +2186,7 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
TRACE("Output limiter disabled\n");
else
{
ALfloat thrshld = 1.0f;
float thrshld{1.0f};
switch(device->FmtType)
{
case DevFmtByte:
@ -2366,7 +2366,7 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
if(device->AvgSpeakerDist > 0.0f)
{
/* Reinitialize the NFC filters for new parameters. */
const ALfloat w1{SPEEDOFSOUNDMETRESPERSEC /
const float w1{SPEEDOFSOUNDMETRESPERSEC /
(device->AvgSpeakerDist * static_cast<float>(device->Frequency))};
for(auto &chandata : voice->mChans)
chandata.mDryParams.NFCtrlFilter.init(w1);
@ -3469,12 +3469,12 @@ START_API_FUNC
if(auto volopt = ConfigValueFloat(dev->DeviceName.c_str(), nullptr, "volume-adjust"))
{
const ALfloat valf{*volopt};
const float valf{*volopt};
if(!std::isfinite(valf))
ERR("volume-adjust must be finite: %f\n", valf);
else
{
const ALfloat db{clampf(valf, -24.0f, 24.0f)};
const float db{clampf(valf, -24.0f, 24.0f)};
if(db != valf)
WARN("volume-adjust clamped: %f, range: +/-%f\n", valf, 24.0f);
context->mGainBoost = std::pow(10.0f, db/20.0f);

100
alc/alu.cpp
View File

@ -357,7 +357,7 @@ inline alu::Vector aluCrossproduct(const alu::Vector &in1, const alu::Vector &in
};
}
inline ALfloat aluDotproduct(const alu::Vector &vec1, const alu::Vector &vec2)
inline float aluDotproduct(const alu::Vector &vec1, const alu::Vector &vec2)
{
return vec1[0]*vec2[0] + vec1[1]*vec2[1] + vec1[2]*vec2[2];
}
@ -511,7 +511,7 @@ bool CalcEffectSlotParams(ALeffectslot *slot, ALeffectslot **sorted_slots, ALCco
*/
inline float ScaleAzimuthFront(float azimuth, float scale)
{
const ALfloat abs_azi{std::fabs(azimuth)};
const float abs_azi{std::fabs(azimuth)};
if(!(abs_azi >= al::MathDefs<float>::Pi()*0.5f))
return std::copysign(minf(abs_azi*scale, al::MathDefs<float>::Pi()*0.5f), azimuth);
return azimuth;
@ -685,8 +685,8 @@ void AmbiRotator(std::array<std::array<float,MAX_AMBI_CHANNELS>,MAX_AMBI_CHANNEL
struct GainTriplet { float Base, HF, LF; };
void CalcPanningAndFilters(Voice *voice, const ALfloat xpos, const ALfloat ypos,
const ALfloat zpos, const ALfloat Distance, const ALfloat Spread, const GainTriplet &DryGain,
void CalcPanningAndFilters(Voice *voice, const float xpos, const float ypos, const float zpos,
const float Distance, const float Spread, const GainTriplet &DryGain,
const al::span<const GainTriplet,MAX_SENDS> WetGain, ALeffectslot *(&SendSlots)[MAX_SENDS],
const VoiceProps *props, const ALlistener &Listener, const ALCdevice *Device)
{
@ -731,7 +731,7 @@ void CalcPanningAndFilters(Voice *voice, const ALfloat xpos, const ALfloat ypos,
{ FrontRight, Deg2Rad( 30.0f), Deg2Rad(0.0f) }
};
const auto Frequency = static_cast<ALfloat>(Device->Frequency);
const auto Frequency = static_cast<float>(Device->Frequency);
const ALuint NumSends{Device->NumAuxSends};
const size_t num_channels{voice->mChans.size()};
@ -747,7 +747,7 @@ void CalcPanningAndFilters(Voice *voice, const ALfloat xpos, const ALfloat ypos,
DirectMode DirectChannels{props->DirectChannels};
const ChanMap *chans{nullptr};
ALfloat downmix_gain{1.0f};
float downmix_gain{1.0f};
switch(voice->mFmtChannels)
{
case FmtMono:
@ -821,8 +821,8 @@ void CalcPanningAndFilters(Voice *voice, const ALfloat xpos, const ALfloat ypos,
/* Clamp the distance for really close sources, to prevent
* excessive bass.
*/
const ALfloat mdist{maxf(Distance, Device->AvgSpeakerDist/4.0f)};
const ALfloat w0{SPEEDOFSOUNDMETRESPERSEC / (mdist * Frequency)};
const float mdist{maxf(Distance, Device->AvgSpeakerDist/4.0f)};
const float w0{SPEEDOFSOUNDMETRESPERSEC / (mdist * Frequency)};
/* Only need to adjust the first channel of a B-Format source. */
voice->mChans[0].mDryParams.NFCtrlFilter.adjust(w0);
@ -830,7 +830,7 @@ void CalcPanningAndFilters(Voice *voice, const ALfloat xpos, const ALfloat ypos,
voice->mFlags |= VOICE_HAS_NFC;
}
ALfloat coeffs[MAX_AMBI_CHANNELS];
float coeffs[MAX_AMBI_CHANNELS];
if(Device->mRenderMode != StereoPair)
CalcDirectionCoeffs({xpos, ypos, zpos}, Spread, coeffs);
else
@ -838,9 +838,9 @@ void CalcPanningAndFilters(Voice *voice, const ALfloat xpos, const ALfloat ypos,
/* Clamp Y, in case rounding errors caused it to end up outside
* of -1...+1.
*/
const ALfloat ev{std::asin(clampf(ypos, -1.0f, 1.0f))};
const float ev{std::asin(clampf(ypos, -1.0f, 1.0f))};
/* Negate Z for right-handed coords with -Z in front. */
const ALfloat az{std::atan2(xpos, -zpos)};
const float az{std::atan2(xpos, -zpos)};
/* A scalar of 1.5 for plain stereo results in +/-60 degrees
* being moved to +/-90 degrees for direct right and left
@ -970,7 +970,7 @@ void CalcPanningAndFilters(Voice *voice, const ALfloat xpos, const ALfloat ypos,
*/
for(size_t c{0};c < num_channels;c++)
{
ALfloat coeffs[MAX_AMBI_CHANNELS];
float coeffs[MAX_AMBI_CHANNELS];
CalcAngleCoeffs(chans[c].angle, chans[c].elevation, 0.0f, coeffs);
for(ALuint i{0};i < NumSends;i++)
@ -990,8 +990,8 @@ void CalcPanningAndFilters(Voice *voice, const ALfloat xpos, const ALfloat ypos,
if(Distance > std::numeric_limits<float>::epsilon())
{
const ALfloat ev{std::asin(clampf(ypos, -1.0f, 1.0f))};
const ALfloat az{std::atan2(xpos, -zpos)};
const float ev{std::asin(clampf(ypos, -1.0f, 1.0f))};
const float az{std::atan2(xpos, -zpos)};
/* Get the HRIR coefficients and delays just once, for the given
* source direction.
@ -1012,7 +1012,7 @@ void CalcPanningAndFilters(Voice *voice, const ALfloat xpos, const ALfloat ypos,
/* Calculate the directional coefficients once, which apply to all
* input channels of the source sends.
*/
ALfloat coeffs[MAX_AMBI_CHANNELS];
float coeffs[MAX_AMBI_CHANNELS];
CalcDirectionCoeffs({xpos, ypos, zpos}, Spread, coeffs);
for(size_t c{0};c < num_channels;c++)
@ -1050,7 +1050,7 @@ void CalcPanningAndFilters(Voice *voice, const ALfloat xpos, const ALfloat ypos,
voice->mChans[c].mDryParams.Hrtf.Target.Gain = DryGain.Base;
/* Normal panning for auxiliary sends. */
ALfloat coeffs[MAX_AMBI_CHANNELS];
float coeffs[MAX_AMBI_CHANNELS];
CalcAngleCoeffs(chans[c].angle, chans[c].elevation, Spread, coeffs);
for(ALuint i{0};i < NumSends;i++)
@ -1076,8 +1076,8 @@ void CalcPanningAndFilters(Voice *voice, const ALfloat xpos, const ALfloat ypos,
/* Clamp the distance for really close sources, to prevent
* excessive bass.
*/
const ALfloat mdist{maxf(Distance, Device->AvgSpeakerDist/4.0f)};
const ALfloat w0{SPEEDOFSOUNDMETRESPERSEC / (mdist * Frequency)};
const float mdist{maxf(Distance, Device->AvgSpeakerDist/4.0f)};
const float w0{SPEEDOFSOUNDMETRESPERSEC / (mdist * Frequency)};
/* Adjust NFC filters. */
for(size_t c{0};c < num_channels;c++)
@ -1089,13 +1089,13 @@ void CalcPanningAndFilters(Voice *voice, const ALfloat xpos, const ALfloat ypos,
/* Calculate the directional coefficients once, which apply to all
* input channels.
*/
ALfloat coeffs[MAX_AMBI_CHANNELS];
float coeffs[MAX_AMBI_CHANNELS];
if(Device->mRenderMode != StereoPair)
CalcDirectionCoeffs({xpos, ypos, zpos}, Spread, coeffs);
else
{
const ALfloat ev{std::asin(clampf(ypos, -1.0f, 1.0f))};
const ALfloat az{std::atan2(xpos, -zpos)};
const float ev{std::asin(clampf(ypos, -1.0f, 1.0f))};
const float az{std::atan2(xpos, -zpos)};
CalcAngleCoeffs(ScaleAzimuthFront(az, 1.5f), ev, Spread, coeffs);
}
@ -1151,7 +1151,7 @@ void CalcPanningAndFilters(Voice *voice, const ALfloat xpos, const ALfloat ypos,
continue;
}
ALfloat coeffs[MAX_AMBI_CHANNELS];
float coeffs[MAX_AMBI_CHANNELS];
CalcAngleCoeffs(
(Device->mRenderMode==StereoPair) ? ScaleAzimuthFront(chans[c].angle, 3.0f)
: chans[c].angle,
@ -1230,8 +1230,8 @@ void CalcNonAttnSourceParams(Voice *voice, const VoiceProps *props, const ALCcon
}
/* Calculate the stepping value */
const auto Pitch = static_cast<ALfloat>(voice->mFrequency) /
static_cast<ALfloat>(Device->Frequency) * props->Pitch;
const auto Pitch = static_cast<float>(voice->mFrequency) /
static_cast<float>(Device->Frequency) * props->Pitch;
if(Pitch > float{MAX_PITCH})
voice->mStep = MAX_PITCH<<FRACTIONBITS;
else
@ -1267,7 +1267,7 @@ void CalcAttnSourceParams(Voice *voice, const VoiceProps *props, const ALCcontex
/* Set mixing buffers and get send parameters. */
voice->mDirect.Buffer = Device->Dry.Buffer;
ALeffectslot *SendSlots[MAX_SENDS];
ALfloat RoomRolloff[MAX_SENDS];
float RoomRolloff[MAX_SENDS];
GainTriplet DecayDistance[MAX_SENDS];
for(ALuint i{0};i < NumSends;i++)
{
@ -1342,7 +1342,7 @@ void CalcAttnSourceParams(Voice *voice, const VoiceProps *props, const ALCcontex
const bool directional{Direction.normalize() > 0.0f};
alu::Vector ToSource{Position[0], Position[1], Position[2], 0.0f};
const ALfloat Distance{ToSource.normalize()};
const float Distance{ToSource.normalize()};
/* Initial source gain */
GainTriplet DryGain{props->Gain, 1.0f, 1.0f};
@ -1507,17 +1507,17 @@ void CalcAttnSourceParams(Voice *voice, const VoiceProps *props, const ALCcontex
/* Initial source pitch */
ALfloat Pitch{props->Pitch};
float Pitch{props->Pitch};
/* Calculate velocity-based doppler effect */
ALfloat DopplerFactor{props->DopplerFactor * Listener.Params.DopplerFactor};
float DopplerFactor{props->DopplerFactor * Listener.Params.DopplerFactor};
if(DopplerFactor > 0.0f)
{
const alu::Vector &lvelocity = Listener.Params.Velocity;
ALfloat vss{aluDotproduct(Velocity, ToSource) * -DopplerFactor};
ALfloat vls{aluDotproduct(lvelocity, ToSource) * -DopplerFactor};
float vss{aluDotproduct(Velocity, ToSource) * -DopplerFactor};
float vls{aluDotproduct(lvelocity, ToSource) * -DopplerFactor};
const ALfloat SpeedOfSound{Listener.Params.SpeedOfSound};
const float SpeedOfSound{Listener.Params.SpeedOfSound};
if(!(vls < SpeedOfSound))
{
/* Listener moving away from the source at the speed of sound.
@ -1544,14 +1544,14 @@ void CalcAttnSourceParams(Voice *voice, const VoiceProps *props, const ALCcontex
/* Adjust pitch based on the buffer and output frequencies, and calculate
* fixed-point stepping value.
*/
Pitch *= static_cast<ALfloat>(voice->mFrequency)/static_cast<ALfloat>(Device->Frequency);
Pitch *= static_cast<float>(voice->mFrequency) / static_cast<float>(Device->Frequency);
if(Pitch > float{MAX_PITCH})
voice->mStep = MAX_PITCH<<FRACTIONBITS;
else
voice->mStep = maxu(fastf2u(Pitch * FRACTIONONE), 1);
voice->mResampler = PrepareResampler(props->mResampler, voice->mStep, &voice->mResampleState);
ALfloat spread{0.0f};
float spread{0.0f};
if(props->Radius > Distance)
spread = al::MathDefs<float>::Tau() - Distance/props->Radius*al::MathDefs<float>::Pi();
else if(Distance > 0.0f)
@ -1831,8 +1831,8 @@ void ApplyStablizer(FrontStablizer *Stablizer, const al::span<FloatBufferLine> B
}
}
ALfloat (&lsplit)[2][BUFFERSIZE] = Stablizer->LSplit;
ALfloat (&rsplit)[2][BUFFERSIZE] = Stablizer->RSplit;
float (&lsplit)[2][BUFFERSIZE] = Stablizer->LSplit;
float (&rsplit)[2][BUFFERSIZE] = Stablizer->RSplit;
const al::span<float> tmpbuf{Stablizer->TempBuf, SamplesToDo+FrontStablizer::DelayLength};
/* This applies the band-splitter, preserving phase at the cost of some
@ -1840,7 +1840,7 @@ void ApplyStablizer(FrontStablizer *Stablizer, const al::span<FloatBufferLine> B
*/
auto apply_splitter = [tmpbuf,SamplesToDo](const FloatBufferLine &InBuf,
const al::span<float,FrontStablizer::DelayLength> DelayBuf, BandSplitter &Filter,
ALfloat (&splitbuf)[2][BUFFERSIZE]) -> void
float (&splitbuf)[2][BUFFERSIZE]) -> void
{
/* Combine the input and delayed samples into a temp buffer in reverse,
* then copy the final samples into the delay buffer for next time.
@ -1868,9 +1868,9 @@ void ApplyStablizer(FrontStablizer *Stablizer, const al::span<FloatBufferLine> B
for(ALuint i{0};i < SamplesToDo;i++)
{
ALfloat lfsum{lsplit[0][i] + rsplit[0][i]};
ALfloat hfsum{lsplit[1][i] + rsplit[1][i]};
ALfloat s{lsplit[0][i] + lsplit[1][i] - rsplit[0][i] - rsplit[1][i]};
float lfsum{lsplit[0][i] + rsplit[0][i]};
float hfsum{lsplit[1][i] + rsplit[1][i]};
float s{lsplit[0][i] + lsplit[1][i] - rsplit[0][i] - rsplit[1][i]};
/* This pans the separate low- and high-frequency sums between being on
* the center channel and the left/right channels. The low-frequency
@ -1878,9 +1878,9 @@ void ApplyStablizer(FrontStablizer *Stablizer, const al::span<FloatBufferLine> B
* frequency sum is 1/4th toward center (3/4ths on left/right). These
* values can be tweaked.
*/
ALfloat m{lfsum*std::cos(1.0f/3.0f * (al::MathDefs<float>::Pi()*0.5f)) +
float m{lfsum*std::cos(1.0f/3.0f * (al::MathDefs<float>::Pi()*0.5f)) +
hfsum*std::cos(1.0f/4.0f * (al::MathDefs<float>::Pi()*0.5f))};
ALfloat c{lfsum*std::sin(1.0f/3.0f * (al::MathDefs<float>::Pi()*0.5f)) +
float c{lfsum*std::sin(1.0f/3.0f * (al::MathDefs<float>::Pi()*0.5f)) +
hfsum*std::sin(1.0f/4.0f * (al::MathDefs<float>::Pi()*0.5f))};
/* The generated center channel signal adds to the existing signal,
@ -1899,15 +1899,15 @@ void ApplyDistanceComp(const al::span<FloatBufferLine> Samples, const ALuint Sam
for(auto &chanbuffer : Samples)
{
const ALfloat gain{distcomp->Gain};
const float gain{distcomp->Gain};
const ALuint base{distcomp->Length};
ALfloat *distbuf{al::assume_aligned<16>(distcomp->Buffer)};
float *distbuf{al::assume_aligned<16>(distcomp->Buffer)};
++distcomp;
if(base < 1)
continue;
ALfloat *inout{al::assume_aligned<16>(chanbuffer.data())};
float *inout{al::assume_aligned<16>(chanbuffer.data())};
auto inout_end = inout + SamplesToDo;
if LIKELY(SamplesToDo >= base)
{
@ -1924,23 +1924,23 @@ void ApplyDistanceComp(const al::span<FloatBufferLine> Samples, const ALuint Sam
}
void ApplyDither(const al::span<FloatBufferLine> Samples, ALuint *dither_seed,
const ALfloat quant_scale, const ALuint SamplesToDo)
const float quant_scale, const ALuint SamplesToDo)
{
/* Dithering. Generate whitenoise (uniform distribution of random values
* between -1 and +1) and add it to the sample values, after scaling up to
* the desired quantization depth amd before rounding.
*/
const ALfloat invscale{1.0f / quant_scale};
const float invscale{1.0f / quant_scale};
ALuint seed{*dither_seed};
auto dither_channel = [&seed,invscale,quant_scale,SamplesToDo](FloatBufferLine &input) -> void
{
ASSUME(SamplesToDo > 0);
auto dither_sample = [&seed,invscale,quant_scale](const ALfloat sample) noexcept -> ALfloat
auto dither_sample = [&seed,invscale,quant_scale](const float sample) noexcept -> float
{
ALfloat val{sample * quant_scale};
float val{sample * quant_scale};
ALuint rng0{dither_rng(&seed)};
ALuint rng1{dither_rng(&seed)};
val += static_cast<ALfloat>(rng0*(1.0/UINT_MAX) - rng1*(1.0/UINT_MAX));
val += static_cast<float>(rng0*(1.0/UINT_MAX) - rng1*(1.0/UINT_MAX));
return fast_roundf(val) * invscale;
};
std::transform(input.begin(), input.begin()+SamplesToDo, input.begin(), dither_sample);
@ -2015,7 +2015,7 @@ void aluMixData(ALCdevice *device, void *OutBuffer, const ALuint NumSamples,
/* Clear main mixing buffers. */
std::for_each(device->MixBuffer.begin(), device->MixBuffer.end(),
[SamplesToDo](std::array<ALfloat,BUFFERSIZE> &buffer) -> void
[SamplesToDo](FloatBufferLine &buffer) -> void
{ std::fill_n(buffer.begin(), SamplesToDo, 0.0f); }
);

18
alc/panning.cpp
View File

@ -147,7 +147,7 @@ void AllocChannels(ALCdevice *device, const ALuint main_chans, const ALuint real
struct ChannelMap {
Channel ChanName;
ALfloat Config[MAX_AMBI2D_CHANNELS];
float Config[MAX_AMBI2D_CHANNELS];
};
bool MakeSpeakerMap(ALCdevice *device, const AmbDecConf *conf, ALuint (&speakermap)[MAX_OUTPUT_CHANNELS])
@ -272,7 +272,7 @@ constexpr ChannelMap MonoCfg[1] = {
{ BackRight, { 2.04124145e-1f, -1.08880247e-1f, -1.88586120e-1f, 1.29099444e-1f, 7.45355993e-2f, -3.73460789e-2f, 0.00000000e+0f } },
};
void InitNearFieldCtrl(ALCdevice *device, ALfloat ctrl_dist, ALuint order, bool is3d)
void InitNearFieldCtrl(ALCdevice *device, float ctrl_dist, ALuint order, bool is3d)
{
/* NFC is only used when AvgSpeakerDist is greater than 0. */
const char *devname{device->DeviceName.c_str()};
@ -297,14 +297,14 @@ void InitDistanceComp(ALCdevice *device, const AmbDecConf *conf,
{
auto get_max = std::bind(maxf, _1,
std::bind(std::mem_fn(&AmbDecConf::SpeakerConf::Distance), _2));
const ALfloat maxdist{
std::accumulate(conf->Speakers.begin(), conf->Speakers.end(), float{0.0f}, get_max)};
const float maxdist{std::accumulate(conf->Speakers.begin(), conf->Speakers.end(), 0.0f,
get_max)};
const char *devname{device->DeviceName.c_str()};
if(!GetConfigValueBool(devname, "decoder", "distance-comp", 1) || !(maxdist > 0.0f))
return;
const auto distSampleScale = static_cast<ALfloat>(device->Frequency)/SPEEDOFSOUNDMETRESPERSEC;
const auto distSampleScale = static_cast<float>(device->Frequency) / SPEEDOFSOUNDMETRESPERSEC;
const auto ChanDelay = device->ChannelDelay.as_span();
size_t total{0u};
for(size_t i{0u};i < conf->Speakers.size();i++)
@ -318,12 +318,12 @@ void InitDistanceComp(ALCdevice *device, const AmbDecConf *conf,
* phase offsets. This means at 48khz, for instance, the distance delay
* will be in steps of about 7 millimeters.
*/
ALfloat delay{std::floor((maxdist - speaker.Distance)*distSampleScale + 0.5f)};
if(delay > ALfloat{MAX_DELAY_LENGTH-1})
float delay{std::floor((maxdist - speaker.Distance)*distSampleScale + 0.5f)};
if(delay > float{MAX_DELAY_LENGTH-1})
{
ERR("Delay for speaker \"%s\" exceeds buffer length (%f > %d)\n",
speaker.Name.c_str(), delay, MAX_DELAY_LENGTH-1);
delay = ALfloat{MAX_DELAY_LENGTH-1};
delay = float{MAX_DELAY_LENGTH-1};
}
ChanDelay[chan].Length = static_cast<ALuint>(delay);
@ -426,7 +426,7 @@ void InitPanning(ALCdevice *device)
);
AllocChannels(device, static_cast<ALuint>(count), 0);
ALfloat nfc_delay{ConfigValueFloat(devname, "decoder", "nfc-ref-delay").value_or(0.0f)};
float nfc_delay{ConfigValueFloat(devname, "decoder", "nfc-ref-delay").value_or(0.0f)};
if(nfc_delay > 0.0f)
InitNearFieldCtrl(device, nfc_delay * SPEEDOFSOUNDMETRESPERSEC, device->mAmbiOrder,
true);

36
alc/voice.cpp
View File

@ -85,9 +85,9 @@ RowMixerFunc MixRowSamples{MixRow_<CTag>};
namespace {
using HrtfMixerFunc = void(*)(const ALfloat *InSamples, float2 *AccumSamples, const ALuint IrSize,
using HrtfMixerFunc = void(*)(const float *InSamples, float2 *AccumSamples, const ALuint IrSize,
const MixHrtfFilter *hrtfparams, const size_t BufferSize);
using HrtfMixerBlendFunc = void(*)(const ALfloat *InSamples, float2 *AccumSamples,
using HrtfMixerBlendFunc = void(*)(const float *InSamples, float2 *AccumSamples,
const ALuint IrSize, const HrtfFilter *oldparams, const MixHrtfFilter *newparams,
const size_t BufferSize);
@ -294,7 +294,7 @@ template<>
struct FmtTypeTraits<FmtDouble> {
using Type = ALdouble;
static constexpr inline float to_float(const Type val) noexcept
{ return static_cast<ALfloat>(val); }
{ return static_cast<float>(val); }
};
template<>
struct FmtTypeTraits<FmtMulaw> {
@ -353,7 +353,7 @@ const float *DoFilters(BiquadFilter *lpfilter, BiquadFilter *hpfilter, float *ds
template<FmtType T>
inline void LoadSampleArray(ALfloat *RESTRICT dst, const al::byte *src, const size_t srcstep,
inline void LoadSampleArray(float *RESTRICT dst, const al::byte *src, const size_t srcstep,
const size_t samples) noexcept
{
using SampleType = typename FmtTypeTraits<T>::Type;
@ -363,7 +363,7 @@ inline void LoadSampleArray(ALfloat *RESTRICT dst, const al::byte *src, const si
dst[i] = FmtTypeTraits<T>::to_float(ssrc[i*srcstep]);
}
void LoadSamples(ALfloat *RESTRICT dst, const al::byte *src, const size_t srcstep, FmtType srctype,
void LoadSamples(float *RESTRICT dst, const al::byte *src, const size_t srcstep, FmtType srctype,
const size_t samples) noexcept
{
#define HANDLE_FMT(T) case T: LoadSampleArray<T>(dst, src, srcstep, samples); break
@ -379,9 +379,9 @@ void LoadSamples(ALfloat *RESTRICT dst, const al::byte *src, const size_t srcste
#undef HANDLE_FMT
}
ALfloat *LoadBufferStatic(ALbufferlistitem *BufferListItem, ALbufferlistitem *&BufferLoopItem,
float *LoadBufferStatic(ALbufferlistitem *BufferListItem, ALbufferlistitem *&BufferLoopItem,
const size_t NumChannels, const size_t SampleSize, const size_t chan, size_t DataPosInt,
al::span<ALfloat> SrcBuffer)
al::span<float> SrcBuffer)
{
const ALbuffer *Buffer{BufferListItem->mBuffer};
const ALuint LoopStart{Buffer->LoopStart};
@ -428,9 +428,9 @@ ALfloat *LoadBufferStatic(ALbufferlistitem *BufferListItem, ALbufferlistitem *&B
return SrcBuffer.begin();
}
ALfloat *LoadBufferCallback(ALbufferlistitem *BufferListItem, const size_t NumChannels,
float *LoadBufferCallback(ALbufferlistitem *BufferListItem, const size_t NumChannels,
const size_t SampleSize, const size_t chan, size_t NumCallbackSamples,
al::span<ALfloat> SrcBuffer)
al::span<float> SrcBuffer)
{
const ALbuffer *Buffer{BufferListItem->mBuffer};
@ -445,9 +445,9 @@ ALfloat *LoadBufferCallback(ALbufferlistitem *BufferListItem, const size_t NumCh
return SrcBuffer.begin();
}
ALfloat *LoadBufferQueue(ALbufferlistitem *BufferListItem, ALbufferlistitem *BufferLoopItem,
float *LoadBufferQueue(ALbufferlistitem *BufferListItem, ALbufferlistitem *BufferLoopItem,
const size_t NumChannels, const size_t SampleSize, const size_t chan, size_t DataPosInt,
al::span<ALfloat> SrcBuffer)
al::span<float> SrcBuffer)
{
/* Crawl the buffer queue to fill in the temp buffer */
while(BufferListItem && !SrcBuffer.empty())
@ -511,7 +511,7 @@ void DoHrtfMix(const float *samples, const ALuint DstBufferSize, DirectParams &p
*/
if LIKELY(Counter > fademix)
{
const ALfloat a{static_cast<float>(fademix) / static_cast<float>(Counter)};
const float a{static_cast<float>(fademix) / static_cast<float>(Counter)};
gain = lerp(parms.Hrtf.Old.Gain, TargetGain, a);
}
MixHrtfFilter hrtfparams;
@ -751,7 +751,7 @@ void Voice::mix(const State vstate, ALCcontext *Context, const ALuint SamplesToD
* silence, but if not the gain fading should help avoid clicks
* from sudden amplitude changes.
*/
const ALfloat sample{*(srciter-1)};
const float sample{*(srciter-1)};
std::fill(srciter, SrcData.end(), sample);
}
@ -760,7 +760,7 @@ void Voice::mix(const State vstate, ALCcontext *Context, const ALuint SamplesToD
chandata.mPrevSamples.size(), chandata.mPrevSamples.begin());
/* Resample, then apply ambisonic upsampling as needed. */
const ALfloat *ResampledData{Resample(&mResampleState,
const float *ResampledData{Resample(&mResampleState,
&SrcData[MAX_RESAMPLER_PADDING>>1], DataPosFrac, increment,
{Device->ResampledData, DstBufferSize})};
if((mFlags&VOICE_IS_AMBISONIC))
@ -777,15 +777,15 @@ void Voice::mix(const State vstate, ALCcontext *Context, const ALuint SamplesToD
}
/* Now filter and mix to the appropriate outputs. */
ALfloat (&FilterBuf)[BUFFERSIZE] = Device->FilteredData;
float (&FilterBuf)[BUFFERSIZE] = Device->FilteredData;
{
DirectParams &parms = chandata.mDryParams;
const ALfloat *samples{DoFilters(&parms.LowPass, &parms.HighPass, FilterBuf,
const float *samples{DoFilters(&parms.LowPass, &parms.HighPass, FilterBuf,
{ResampledData, DstBufferSize}, mDirect.FilterType)};
if((mFlags&VOICE_HAS_HRTF))
{
const ALfloat TargetGain{UNLIKELY(vstate == Stopping) ? 0.0f :
const float TargetGain{UNLIKELY(vstate == Stopping) ? 0.0f :
parms.Hrtf.Target.Gain};
DoHrtfMix(samples, DstBufferSize, parms, TargetGain, Counter, OutPos, IrSize,
Device);
@ -812,7 +812,7 @@ void Voice::mix(const State vstate, ALCcontext *Context, const ALuint SamplesToD
continue;
SendParams &parms = chandata.mWetParams[send];
const ALfloat *samples{DoFilters(&parms.LowPass, &parms.HighPass, FilterBuf,
const float *samples{DoFilters(&parms.LowPass, &parms.HighPass, FilterBuf,
{ResampledData, DstBufferSize}, mSend[send].FilterType)};
const float *TargetGains{UNLIKELY(vstate == Stopping) ? SilentTarget.data()