diff options
| -rw-r--r-- | alc/alu.cpp | 8 | ||||
| -rw-r--r-- | alc/bsinc_defs.h | 15 | ||||
| -rw-r--r-- | alc/bsinc_tables.cpp | 89 | ||||
| -rw-r--r-- | alc/bsinc_tables.h | 4 | ||||
| -rw-r--r-- | alc/mixer/mixer_c.cpp | 12 | ||||
| -rw-r--r-- | alc/mixer/mixer_neon.cpp | 14 | ||||
| -rw-r--r-- | alc/mixer/mixer_sse.cpp | 14 |
7 files changed, 74 insertions, 82 deletions
diff --git a/alc/alu.cpp b/alc/alu.cpp index bda8b08d..ba44980c 100644 --- a/alc/alu.cpp +++ b/alc/alu.cpp @@ -103,8 +103,8 @@ struct BSincTag; struct FastBSincTag; -static_assert(!(MAX_RESAMPLER_PADDING&1) && MAX_RESAMPLER_PADDING >= BSINC_POINTS_MAX, - "MAX_RESAMPLER_PADDING is not a multiple of two, or is too small"); +static_assert(MAX_RESAMPLER_PADDING >= BSincPointsMax, "MAX_RESAMPLER_PADDING is too small"); +static_assert(!(MAX_RESAMPLER_PADDING&1), "MAX_RESAMPLER_PADDING is not a multiple of two"); namespace { @@ -174,13 +174,13 @@ inline HrtfDirectMixerFunc SelectHrtfMixer(void) inline void BsincPrepare(const ALuint increment, BsincState *state, const BSincTable *table) { - size_t si{BSINC_SCALE_COUNT - 1}; + size_t si{BSincScaleCount - 1}; float sf{0.0f}; if(increment > FRACTIONONE) { sf = FRACTIONONE / static_cast<float>(increment); - sf = maxf(0.0f, (BSINC_SCALE_COUNT-1) * (sf-table->scaleBase) * table->scaleRange); + sf = maxf(0.0f, (BSincScaleCount-1) * (sf-table->scaleBase) * table->scaleRange); si = float2uint(sf); /* The interpolation factor is fit to this diagonally-symmetric curve * to reduce the transition ripple caused by interpolating different diff --git a/alc/bsinc_defs.h b/alc/bsinc_defs.h index 30d1219e..179e025d 100644 --- a/alc/bsinc_defs.h +++ b/alc/bsinc_defs.h @@ -2,12 +2,15 @@ #define BSINC_DEFS_H /* The number of distinct scale and phase intervals within the filter table. */ -#define BSINC_SCALE_BITS 4 -#define BSINC_SCALE_COUNT (1<<BSINC_SCALE_BITS) -#define BSINC_PHASE_BITS 5 -#define BSINC_PHASE_COUNT (1<<BSINC_PHASE_BITS) +constexpr unsigned int BSincScaleBits{4}; +constexpr unsigned int BSincScaleCount{1 << BSincScaleBits}; +constexpr unsigned int BSincPhaseBits{5}; +constexpr unsigned int BSincPhaseCount{1 << BSincPhaseBits}; -/* The maximum number of sample points for the bsinc filters. */ -#define BSINC_POINTS_MAX 48 +/* The maximum number of sample points for the bsinc filters. The max points + * includes the doubling for downsampling, so the maximum number of base sample + * points is 24, which is 23rd order. + */ +constexpr unsigned int BSincPointsMax{48}; #endif /* BSINC_DEFS_H */ diff --git a/alc/bsinc_tables.cpp b/alc/bsinc_tables.cpp index c1a7d054..6052e1b1 100644 --- a/alc/bsinc_tables.cpp +++ b/alc/bsinc_tables.cpp @@ -15,14 +15,7 @@ namespace { -/* The max points includes the doubling for downsampling, so the maximum number - * of base sample points is 24, which is 23rd order. - */ -constexpr int BSincPointsMax{BSINC_POINTS_MAX}; -constexpr int BSincPointsHalf{BSincPointsMax / 2}; - -constexpr int BSincPhaseCount{BSINC_PHASE_COUNT}; -constexpr int BSincScaleCount{BSINC_SCALE_COUNT}; +using uint = unsigned int; /* This is the normalized cardinal sine (sinc) function. @@ -90,10 +83,10 @@ constexpr double Kaiser(const double beta, const double k, const double besseli_ /* Calculates the (normalized frequency) transition width of the Kaiser window. * Rejection is in dB. */ -constexpr double CalcKaiserWidth(const double rejection, const int order) +constexpr double CalcKaiserWidth(const double rejection, const uint order) { if(rejection > 21.19) - return (rejection - 7.95) / (order * 2.285 * al::MathDefs<double>::Tau()); + return (rejection - 7.95) / (order * 2.285 * al::MathDefs<double>::Tau()); /* This enforces a minimum rejection of just above 21.18dB */ return 5.79 / (order * al::MathDefs<double>::Tau()); } @@ -102,9 +95,9 @@ constexpr double CalcKaiserWidth(const double rejection, const int order) constexpr double CalcKaiserBeta(const double rejection) { if(rejection > 50.0) - return 0.1102 * (rejection-8.7); + return 0.1102 * (rejection-8.7); else if(rejection >= 21.0) - return (0.5842 * std::pow(rejection-21.0, 0.4)) + (0.07886 * (rejection-21.0)); + return (0.5842 * std::pow(rejection-21.0, 0.4)) + (0.07886 * (rejection-21.0)); return 0.0; } @@ -116,10 +109,10 @@ struct BSincHeader { double scaleRange{}; double besseli_0_beta{}; - int a[BSINC_SCALE_COUNT]{}; - int total_size{}; + uint a[BSincScaleCount]{}; + uint total_size{}; - constexpr BSincHeader(int Rejection, int Order) noexcept + constexpr BSincHeader(uint Rejection, uint Order) noexcept { width = CalcKaiserWidth(Rejection, Order); beta = CalcKaiserBeta(Rejection); @@ -127,15 +120,15 @@ struct BSincHeader { scaleRange = 1.0 - scaleBase; besseli_0_beta = BesselI_0(beta); - int num_points{Order+1}; - for(int si{0};si < BSincScaleCount;++si) + uint num_points{Order+1}; + for(uint si{0};si < BSincScaleCount;++si) { - const double scale{scaleBase + (scaleRange * si / (BSincScaleCount - 1))}; - const int a_{std::min(static_cast<int>(num_points / 2.0 / scale), num_points)}; - const int m{2 * a_}; + const double scale{scaleBase + (scaleRange * si / (BSincScaleCount-1))}; + const uint a_{std::min(static_cast<uint>(num_points / 2.0 / scale), num_points)}; + const uint m{2 * a_}; a[si] = a_; - total_size += 4 * BSincPhaseCount * ((m+3) & ~3); + total_size += 4 * BSincPhaseCount * ((m+3) & ~3u); } } }; @@ -164,23 +157,23 @@ struct BSincFilterArray { /* Calculate the Kaiser-windowed Sinc filter coefficients for each * scale and phase index. */ - for(unsigned int si{0};si < BSincScaleCount;++si) + for(uint si{0};si < BSincScaleCount;++si) { - const int m{hdr.a[si] * 2}; - const int o{BSincPointsHalf - (m/2)}; - const int l{hdr.a[si] - 1}; - const int a{hdr.a[si]}; - const double scale{hdr.scaleBase + (hdr.scaleRange * si / (BSincScaleCount - 1))}; + const uint m{hdr.a[si] * 2}; + const size_t o{(BSincPointsMax-m) / 2}; + const double scale{hdr.scaleBase + (hdr.scaleRange * si / (BSincScaleCount-1))}; const double cutoff{scale - (hdr.scaleBase * std::max(0.5, scale) * 2.0)}; + const auto a = static_cast<double>(hdr.a[si]); + const double l{a - 1.0}; /* Do one extra phase index so that the phase delta has a proper * target for its last index. */ - for(int pi{0};pi <= BSincPhaseCount;++pi) + for(uint pi{0};pi <= BSincPhaseCount;++pi) { const double phase{l + (pi/double{BSincPhaseCount})}; - for(int i{0};i < m;++i) + for(uint i{0};i < m;++i) { const double x{i - phase}; filter[si][pi][o+i] = Kaiser(hdr.beta, x/a, hdr.besseli_0_beta) * cutoff * @@ -190,23 +183,23 @@ struct BSincFilterArray { } size_t idx{0}; - for(unsigned int si{0};si < BSincScaleCount-1;++si) + for(size_t si{0};si < BSincScaleCount-1;++si) { - const int m{((hdr.a[si]*2) + 3) & ~3}; - const int o{BSincPointsHalf - (m/2)}; + const size_t m{((hdr.a[si]*2) + 3) & ~3u}; + const size_t o{(BSincPointsMax-m) / 2}; - for(int pi{0};pi < BSincPhaseCount;++pi) + for(size_t pi{0};pi < BSincPhaseCount;++pi) { /* Write out the filter. Also calculate and write out the phase * and scale deltas. */ - for(int i{0};i < m;++i) + for(size_t i{0};i < m;++i) mTable[idx++] = static_cast<float>(filter[si][pi][o+i]); /* Linear interpolation between phases is simplified by pre- * calculating the delta (b - a) in: x = a + f (b - a) */ - for(int i{0};i < m;++i) + for(size_t i{0};i < m;++i) { const double phDelta{filter[si][pi+1][o+i] - filter[si][pi][o+i]}; mTable[idx++] = static_cast<float>(phDelta); @@ -217,7 +210,7 @@ struct BSincFilterArray { * Given a difference in points between scales, the destination * points will be 0, thus: x = a + f (-a) */ - for(int i{0};i < m;++i) + for(size_t i{0};i < m;++i) { const double scDelta{filter[si+1][pi][o+i] - filter[si][pi][o+i]}; mTable[idx++] = static_cast<float>(scDelta); @@ -226,7 +219,7 @@ struct BSincFilterArray { /* This last simplification is done to complete the bilinear * equation for the combination of phase and scale. */ - for(int i{0};i < m;++i) + for(size_t i{0};i < m;++i) { const double spDelta{(filter[si+1][pi+1][o+i] - filter[si+1][pi][o+i]) - (filter[si][pi+1][o+i] - filter[si][pi][o+i])}; @@ -238,22 +231,22 @@ struct BSincFilterArray { /* The last scale index doesn't have any scale or scale-phase * deltas. */ - const unsigned int si{BSincScaleCount - 1}; - const int m{((hdr.a[si]*2) + 3) & ~3}; - const int o{BSincPointsHalf - (m/2)}; + constexpr size_t si{BSincScaleCount-1}; + const size_t m{((hdr.a[si]*2) + 3) & ~3u}; + const size_t o{(BSincPointsMax-m) / 2}; - for(int pi{0};pi < BSincPhaseCount;++pi) + for(size_t pi{0};pi < BSincPhaseCount;++pi) { - for(int i{0};i < m;++i) + for(size_t i{0};i < m;++i) mTable[idx++] = static_cast<float>(filter[si][pi][o+i]); - for(int i{0};i < m;++i) + for(size_t i{0};i < m;++i) { const double phDelta{filter[si][pi+1][o+i] - filter[si][pi][o+i]}; mTable[idx++] = static_cast<float>(phDelta); } - for(int i{0};i < m;++i) + for(size_t i{0};i < m;++i) mTable[idx++] = 0.0f; - for(int i{0};i < m;++i) + for(size_t i{0};i < m;++i) mTable[idx++] = 0.0f; } } @@ -273,10 +266,10 @@ constexpr BSincTable GenerateBSincTable(const BSincHeader &hdr, const float *tab BSincTable ret{}; ret.scaleBase = static_cast<float>(hdr.scaleBase); ret.scaleRange = static_cast<float>(1.0 / hdr.scaleRange); - for(int i{0};i < BSincScaleCount;++i) - ret.m[i] = static_cast<unsigned int>(((hdr.a[i]*2) + 3) & ~3); + for(size_t i{0};i < BSincScaleCount;++i) + ret.m[i] = ((hdr.a[i]*2) + 3) & ~3u; ret.filterOffset[0] = 0; - for(int i{1};i < BSincScaleCount;++i) + for(size_t i{1};i < BSincScaleCount;++i) ret.filterOffset[i] = ret.filterOffset[i-1] + ret.m[i-1]*4*BSincPhaseCount; ret.Tab = tab; return ret; diff --git a/alc/bsinc_tables.h b/alc/bsinc_tables.h index 2e2443e5..8e37336d 100644 --- a/alc/bsinc_tables.h +++ b/alc/bsinc_tables.h @@ -6,8 +6,8 @@ struct BSincTable { float scaleBase, scaleRange; - unsigned int m[BSINC_SCALE_COUNT]; - unsigned int filterOffset[BSINC_SCALE_COUNT]; + unsigned int m[BSincScaleCount]; + unsigned int filterOffset[BSincScaleCount]; const float *Tab; }; diff --git a/alc/mixer/mixer_c.cpp b/alc/mixer/mixer_c.cpp index b665b0a5..af8ff3b1 100644 --- a/alc/mixer/mixer_c.cpp +++ b/alc/mixer/mixer_c.cpp @@ -21,8 +21,8 @@ struct FastBSincTag; namespace { -#define FRAC_PHASE_BITDIFF (FRACTIONBITS - BSINC_PHASE_BITS) -#define FRAC_PHASE_DIFFONE (1<<FRAC_PHASE_BITDIFF) +constexpr ALuint FracPhaseBitDiff{FRACTIONBITS - BSincPhaseBits}; +constexpr ALuint FracPhaseDiffOne{1 << FracPhaseBitDiff}; inline float do_point(const InterpState&, const float *RESTRICT vals, const ALuint) { return vals[0]; } @@ -35,8 +35,8 @@ inline float do_bsinc(const InterpState &istate, const float *RESTRICT vals, con const size_t m{istate.bsinc.m}; // Calculate the phase index and factor. - const ALuint pi{frac >> FRAC_PHASE_BITDIFF}; - const float pf{static_cast<float>(frac & (FRAC_PHASE_DIFFONE-1)) * (1.0f/FRAC_PHASE_DIFFONE)}; + const ALuint pi{frac >> FracPhaseBitDiff}; + const float pf{static_cast<float>(frac & (FracPhaseDiffOne-1)) * (1.0f/FracPhaseDiffOne)}; const float *fil{istate.bsinc.filter + m*pi*4}; const float *phd{fil + m}; @@ -54,8 +54,8 @@ inline float do_fastbsinc(const InterpState &istate, const float *RESTRICT vals, const size_t m{istate.bsinc.m}; // Calculate the phase index and factor. - const ALuint pi{frac >> FRAC_PHASE_BITDIFF}; - const float pf{static_cast<float>(frac & (FRAC_PHASE_DIFFONE-1)) * (1.0f/FRAC_PHASE_DIFFONE)}; + const ALuint pi{frac >> FracPhaseBitDiff}; + const float pf{static_cast<float>(frac & (FracPhaseDiffOne-1)) * (1.0f/FracPhaseDiffOne)}; const float *fil{istate.bsinc.filter + m*pi*4}; const float *phd{fil + m}; diff --git a/alc/mixer/mixer_neon.cpp b/alc/mixer/mixer_neon.cpp index 9d21b1c5..2573e791 100644 --- a/alc/mixer/mixer_neon.cpp +++ b/alc/mixer/mixer_neon.cpp @@ -21,8 +21,8 @@ struct FastBSincTag; namespace { -#define FRAC_PHASE_BITDIFF (FRACTIONBITS - BSINC_PHASE_BITS) -#define FRAC_PHASE_DIFFONE (1<<FRAC_PHASE_BITDIFF) +constexpr ALuint FracPhaseBitDiff{FRACTIONBITS - BSincPhaseBits}; +constexpr ALuint FracPhaseDiffOne{1 << FracPhaseBitDiff}; inline void ApplyCoeffs(float2 *RESTRICT Values, const uint_fast32_t IrSize, const HrirArray &Coeffs, const float left, const float right) @@ -114,9 +114,8 @@ const float *Resample_<BSincTag,NEONTag>(const InterpState *state, const float * for(float &out_sample : dst) { // Calculate the phase index and factor. - const ALuint pi{frac >> FRAC_PHASE_BITDIFF}; - const float pf{static_cast<float>(frac & (FRAC_PHASE_DIFFONE-1)) * - (1.0f/FRAC_PHASE_DIFFONE)}; + const ALuint pi{frac >> FracPhaseBitDiff}; + const float pf{static_cast<float>(frac & (FracPhaseDiffOne-1)) * (1.0f/FracPhaseDiffOne)}; // Apply the scale and phase interpolated filter. float32x4_t r4{vdupq_n_f32(0.0f)}; @@ -160,9 +159,8 @@ const float *Resample_<FastBSincTag,NEONTag>(const InterpState *state, for(float &out_sample : dst) { // Calculate the phase index and factor. - const ALuint pi{frac >> FRAC_PHASE_BITDIFF}; - const float pf{static_cast<float>(frac & (FRAC_PHASE_DIFFONE-1)) * - (1.0f/FRAC_PHASE_DIFFONE)}; + const ALuint pi{frac >> FracPhaseBitDiff}; + const float pf{static_cast<float>(frac & (FracPhaseDiffOne-1)) * (1.0f/FracPhaseDiffOne)}; // Apply the phase interpolated filter. float32x4_t r4{vdupq_n_f32(0.0f)}; diff --git a/alc/mixer/mixer_sse.cpp b/alc/mixer/mixer_sse.cpp index d2e021ff..85cddcae 100644 --- a/alc/mixer/mixer_sse.cpp +++ b/alc/mixer/mixer_sse.cpp @@ -20,8 +20,8 @@ struct FastBSincTag; namespace { -#define FRAC_PHASE_BITDIFF (FRACTIONBITS - BSINC_PHASE_BITS) -#define FRAC_PHASE_DIFFONE (1<<FRAC_PHASE_BITDIFF) +constexpr ALuint FracPhaseBitDiff{FRACTIONBITS - BSincPhaseBits}; +constexpr ALuint FracPhaseDiffOne{1 << FracPhaseBitDiff}; #define MLA4(x, y, z) _mm_add_ps(x, _mm_mul_ps(y, z)) @@ -86,9 +86,8 @@ const float *Resample_<BSincTag,SSETag>(const InterpState *state, const float *R for(float &out_sample : dst) { // Calculate the phase index and factor. - const ALuint pi{frac >> FRAC_PHASE_BITDIFF}; - const float pf{static_cast<float>(frac & (FRAC_PHASE_DIFFONE-1)) * - (1.0f/FRAC_PHASE_DIFFONE)}; + const ALuint pi{frac >> FracPhaseBitDiff}; + const float pf{static_cast<float>(frac & (FracPhaseDiffOne-1)) * (1.0f/FracPhaseDiffOne)}; // Apply the scale and phase interpolated filter. __m128 r4{_mm_setzero_ps()}; @@ -133,9 +132,8 @@ const float *Resample_<FastBSincTag,SSETag>(const InterpState *state, const floa for(float &out_sample : dst) { // Calculate the phase index and factor. - const ALuint pi{frac >> FRAC_PHASE_BITDIFF}; - const float pf{static_cast<float>(frac & (FRAC_PHASE_DIFFONE-1)) * - (1.0f/FRAC_PHASE_DIFFONE)}; + const ALuint pi{frac >> FracPhaseBitDiff}; + const float pf{static_cast<float>(frac & (FracPhaseDiffOne-1)) * (1.0f/FracPhaseDiffOne)}; // Apply the phase interpolated filter. __m128 r4{_mm_setzero_ps()}; |