#include "config.h" #include #include #include #include "alnumeric.h" #include "core/bsinc_defs.h" #include "core/cubic_defs.h" #include "defs.h" #include "hrtfbase.h" struct CTag; struct PointTag; struct LerpTag; struct CubicTag; struct BSincTag; struct FastBSincTag; namespace { constexpr uint BsincPhaseDiffBits{MixerFracBits - BSincPhaseBits}; constexpr uint BsincPhaseDiffOne{1 << BsincPhaseDiffBits}; constexpr uint BsincPhaseDiffMask{BsincPhaseDiffOne - 1u}; constexpr uint CubicPhaseDiffBits{MixerFracBits - CubicPhaseBits}; constexpr uint CubicPhaseDiffOne{1 << CubicPhaseDiffBits}; constexpr uint CubicPhaseDiffMask{CubicPhaseDiffOne - 1u}; inline float do_point(const float *RESTRICT vals, const uint) { return vals[0]; } inline float do_lerp(const float *RESTRICT vals, const uint frac) { return lerpf(vals[0], vals[1], static_cast(frac)*(1.0f/MixerFracOne)); } inline float do_cubic(const CubicState &istate, const float *RESTRICT vals, const uint frac) { /* Calculate the phase index and factor. */ const uint pi{frac >> CubicPhaseDiffBits}; const float pf{static_cast(frac&CubicPhaseDiffMask) * (1.0f/CubicPhaseDiffOne)}; const float *RESTRICT fil{al::assume_aligned<16>(istate.filter[pi].mCoeffs.data())}; const float *RESTRICT phd{al::assume_aligned<16>(istate.filter[pi].mDeltas.data())}; /* Apply the phase interpolated filter. */ return (fil[0] + pf*phd[0])*vals[0] + (fil[1] + pf*phd[1])*vals[1] + (fil[2] + pf*phd[2])*vals[2] + (fil[3] + pf*phd[3])*vals[3]; } inline float do_bsinc(const BsincState &istate, const float *RESTRICT vals, const uint frac) { const size_t m{istate.m}; ASSUME(m > 0); /* Calculate the phase index and factor. */ const uint pi{frac >> BsincPhaseDiffBits}; const float pf{static_cast(frac&BsincPhaseDiffMask) * (1.0f/BsincPhaseDiffOne)}; const float *RESTRICT fil{istate.filter + m*pi*2}; const float *RESTRICT phd{fil + m}; const float *RESTRICT scd{fil + BSincPhaseCount*2*m}; const float *RESTRICT spd{scd + m}; /* Apply the scale and phase interpolated filter. */ float r{0.0f}; for(size_t j_f{0};j_f < m;j_f++) r += (fil[j_f] + istate.sf*scd[j_f] + pf*(phd[j_f] + istate.sf*spd[j_f])) * vals[j_f]; return r; } inline float do_fastbsinc(const BsincState &istate, const float *RESTRICT vals, const uint frac) { const size_t m{istate.m}; ASSUME(m > 0); /* Calculate the phase index and factor. */ const uint pi{frac >> BsincPhaseDiffBits}; const float pf{static_cast(frac&BsincPhaseDiffMask) * (1.0f/BsincPhaseDiffOne)}; const float *RESTRICT fil{istate.filter + m*pi*2}; const float *RESTRICT phd{fil + m}; /* Apply the phase interpolated filter. */ float r{0.0f}; for(size_t j_f{0};j_f < m;j_f++) r += (fil[j_f] + pf*phd[j_f]) * vals[j_f]; return r; } using SamplerT = float(&)(const float*RESTRICT, const uint); template void DoResample(const float *RESTRICT src, uint frac, const uint increment, const al::span dst) { ASSUME(frac < MixerFracOne); for(float &out : dst) { out = Sampler(src, frac); frac += increment; src += frac>>MixerFracBits; frac &= MixerFracMask; } } template void DoResample(T sampler, const U istate, const float *RESTRICT src, uint frac, const uint increment, const al::span dst) { ASSUME(frac < MixerFracOne); for(float &out : dst) { out = sampler(istate, src, frac); frac += increment; src += frac>>MixerFracBits; frac &= MixerFracMask; } } inline void ApplyCoeffs(float2 *RESTRICT Values, const size_t IrSize, const ConstHrirSpan Coeffs, const float left, const float right) { ASSUME(IrSize >= MinIrLength); for(size_t c{0};c < IrSize;++c) { Values[c][0] += Coeffs[c][0] * left; Values[c][1] += Coeffs[c][1] * right; } } force_inline void MixLine(const al::span InSamples, float *RESTRICT dst, float &CurrentGain, const float TargetGain, const float delta, const size_t min_len, size_t Counter) { float gain{CurrentGain}; const float step{(TargetGain-gain) * delta}; size_t pos{0}; if(!(std::abs(step) > std::numeric_limits::epsilon())) gain = TargetGain; else { float step_count{0.0f}; for(;pos != min_len;++pos) { dst[pos] += InSamples[pos] * (gain + step*step_count); step_count += 1.0f; } if(pos == Counter) gain = TargetGain; else gain += step*step_count; } CurrentGain = gain; if(!(std::abs(gain) > GainSilenceThreshold)) return; for(;pos != InSamples.size();++pos) dst[pos] += InSamples[pos] * gain; } } // namespace template<> void Resample_(const InterpState*, const float *RESTRICT src, uint frac, const uint increment, const al::span dst) { DoResample(src, frac, increment, dst); } template<> void Resample_(const InterpState*, const float *RESTRICT src, uint frac, const uint increment, const al::span dst) { DoResample(src, frac, increment, dst); } template<> void Resample_(const InterpState *state, const float *RESTRICT src, uint frac, const uint increment, const al::span dst) { DoResample(do_cubic, std::get(*state), src-1, frac, increment, dst); } template<> void Resample_(const InterpState *state, const float *RESTRICT src, uint frac, const uint increment, const al::span dst) { const auto istate = std::get(*state); DoResample(do_bsinc, istate, src-istate.l, frac, increment, dst); } template<> void Resample_(const InterpState *state, const float *RESTRICT src, uint frac, const uint increment, const al::span dst) { const auto istate = std::get(*state); DoResample(do_fastbsinc, istate, src-istate.l, frac, increment, dst); } template<> void MixHrtf_(const float *InSamples, float2 *AccumSamples, const uint IrSize, const MixHrtfFilter *hrtfparams, const size_t BufferSize) { MixHrtfBase(InSamples, AccumSamples, IrSize, hrtfparams, BufferSize); } template<> void MixHrtfBlend_(const float *InSamples, float2 *AccumSamples, const uint IrSize, const HrtfFilter *oldparams, const MixHrtfFilter *newparams, const size_t BufferSize) { MixHrtfBlendBase(InSamples, AccumSamples, IrSize, oldparams, newparams, BufferSize); } template<> void MixDirectHrtf_(const FloatBufferSpan LeftOut, const FloatBufferSpan RightOut, const al::span InSamples, float2 *AccumSamples, float *TempBuf, HrtfChannelState *ChanState, const size_t IrSize, const size_t BufferSize) { MixDirectHrtfBase(LeftOut, RightOut, InSamples, AccumSamples, TempBuf, ChanState, IrSize, BufferSize); } template<> void Mix_(const al::span InSamples, const al::span OutBuffer, float *CurrentGains, const float *TargetGains, const size_t Counter, const size_t OutPos) { const float delta{(Counter > 0) ? 1.0f / static_cast(Counter) : 0.0f}; const auto min_len = minz(Counter, InSamples.size()); for(FloatBufferLine &output : OutBuffer) MixLine(InSamples, al::assume_aligned<16>(output.data()+OutPos), *CurrentGains++, *TargetGains++, delta, min_len, Counter); } template<> void Mix_(const al::span InSamples, float *OutBuffer, float &CurrentGain, const float TargetGain, const size_t Counter) { const float delta{(Counter > 0) ? 1.0f / static_cast(Counter) : 0.0f}; const auto min_len = minz(Counter, InSamples.size()); MixLine(InSamples, al::assume_aligned<16>(OutBuffer), CurrentGain, TargetGain, delta, min_len, Counter); }