#include "config.h" #include #include #include "alcmain.h" #include "alu.h" #include "defs.h" #include "hrtfbase.h" namespace { inline ALfloat do_point(const InterpState&, const ALfloat *RESTRICT vals, const ALsizei) { return vals[0]; } inline ALfloat do_lerp(const InterpState&, const ALfloat *RESTRICT vals, const ALsizei frac) { return lerp(vals[0], vals[1], frac * (1.0f/FRACTIONONE)); } inline ALfloat do_cubic(const InterpState&, const ALfloat *RESTRICT vals, const ALsizei frac) { return cubic(vals[0], vals[1], vals[2], vals[3], frac * (1.0f/FRACTIONONE)); } inline ALfloat do_bsinc(const InterpState &istate, const ALfloat *RESTRICT vals, const ALsizei frac) { ASSUME(istate.bsinc.m > 0); // Calculate the phase index and factor. #define FRAC_PHASE_BITDIFF (FRACTIONBITS-BSINC_PHASE_BITS) const ALsizei pi{frac >> FRAC_PHASE_BITDIFF}; const ALfloat pf{(frac & ((1< const ALfloat *DoResample(const InterpState *state, const ALfloat *RESTRICT src, ALsizei frac, ALint increment, const al::span dst) { ASSUME(increment > 0); ASSUME(frac >= 0); const InterpState istate{*state}; auto proc_sample = [&src,&frac,istate,increment]() -> ALfloat { const ALfloat ret{Sampler(istate, src, frac)}; frac += increment; src += frac>>FRACTIONBITS; frac &= FRACTIONMASK; return ret; }; std::generate(dst.begin(), dst.end(), proc_sample); return dst.begin(); } } // namespace template<> const ALfloat *Resample_(const InterpState*, const ALfloat *RESTRICT src, ALsizei, ALint, const al::span dst) { #if defined(HAVE_SSE) || defined(HAVE_NEON) /* Avoid copying the source data if it's aligned like the destination. */ if((reinterpret_cast(src)&15) == (reinterpret_cast(dst.data())&15)) return src; #endif std::copy_n(src, dst.size(), dst.begin()); return dst.begin(); } template<> const ALfloat *Resample_(const InterpState *state, const ALfloat *RESTRICT src, ALsizei frac, ALint increment, const al::span dst) { return DoResample(state, src, frac, increment, dst); } template<> const ALfloat *Resample_(const InterpState *state, const ALfloat *RESTRICT src, ALsizei frac, ALint increment, const al::span dst) { return DoResample(state, src, frac, increment, dst); } template<> const ALfloat *Resample_(const InterpState *state, const ALfloat *RESTRICT src, ALsizei frac, ALint increment, const al::span dst) { return DoResample(state, src-1, frac, increment, dst); } template<> const ALfloat *Resample_(const InterpState *state, const ALfloat *RESTRICT src, ALsizei frac, ALint increment, const al::span dst) { return DoResample(state, src-state->bsinc.l, frac, increment, dst); } static inline void ApplyCoeffs(size_t /*Offset*/, float2 *RESTRICT Values, const ALsizei IrSize, const HrirArray &Coeffs, const ALfloat left, const ALfloat right) { ASSUME(IrSize >= 2); for(ALsizei c{0};c < IrSize;++c) { Values[c][0] += Coeffs[c][0] * left; Values[c][1] += Coeffs[c][1] * right; } } template<> void MixHrtf_(FloatBufferLine &LeftOut, FloatBufferLine &RightOut, const ALfloat *InSamples, float2 *AccumSamples, const size_t OutPos, const ALsizei IrSize, MixHrtfFilter *hrtfparams, const size_t BufferSize) { MixHrtfBase(LeftOut, RightOut, InSamples, AccumSamples, OutPos, IrSize, hrtfparams, BufferSize); } template<> void MixHrtfBlend_(FloatBufferLine &LeftOut, FloatBufferLine &RightOut, const ALfloat *InSamples, float2 *AccumSamples, const size_t OutPos, const ALsizei IrSize, const HrtfFilter *oldparams, MixHrtfFilter *newparams, const size_t BufferSize) { MixHrtfBlendBase(LeftOut, RightOut, InSamples, AccumSamples, OutPos, IrSize, oldparams, newparams, BufferSize); } template<> void MixDirectHrtf_(FloatBufferLine &LeftOut, FloatBufferLine &RightOut, const al::span InSamples, float2 *AccumSamples, DirectHrtfState *State, const size_t BufferSize) { MixDirectHrtfBase(LeftOut, RightOut, InSamples, AccumSamples, State, 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 ALfloat delta{(Counter > 0) ? 1.0f / static_cast(Counter) : 0.0f}; const bool reached_target{InSamples.size() >= Counter}; const auto min_end = reached_target ? InSamples.begin() + Counter : InSamples.end(); for(FloatBufferLine &output : OutBuffer) { ALfloat *RESTRICT dst{al::assume_aligned<16>(output.data()+OutPos)}; ALfloat gain{*CurrentGains}; const ALfloat diff{*TargetGains - gain}; auto in_iter = InSamples.begin(); if(std::fabs(diff) > std::numeric_limits::epsilon()) { const ALfloat step{diff * delta}; ALfloat step_count{0.0f}; while(in_iter != min_end) { *(dst++) += *(in_iter++) * (gain + step*step_count); step_count += 1.0f; } if(reached_target) gain = *TargetGains; else gain += step*step_count; *CurrentGains = gain; } ++CurrentGains; ++TargetGains; if(!(std::fabs(gain) > GAIN_SILENCE_THRESHOLD)) continue; while(in_iter != InSamples.end()) *(dst++) += *(in_iter++) * gain; } } /* Basically the inverse of the above. Rather than one input going to multiple * outputs (each with its own gain), it's multiple inputs (each with its own * gain) going to one output. This applies one row (vs one column) of a matrix * transform. And as the matrices are more or less static once set up, no * stepping is necessary. */ template<> void MixRow_(const al::span OutBuffer, const al::span Gains, const float *InSamples, const size_t InStride) { for(const float gain : Gains) { const float *RESTRICT src{InSamples}; InSamples += InStride; if(!(std::fabs(gain) > GAIN_SILENCE_THRESHOLD)) continue; std::transform(OutBuffer.begin(), OutBuffer.end(), src, OutBuffer.begin(), [gain](const ALfloat cur, const ALfloat src) -> ALfloat { return cur + src*gain; }); } }