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

Use constexpr variables in place of some macros

Browse Source
This commit is contained in:
Chris Robinson 2020-10-19 07:55:25 -07:00
parent d6686bceb0
commit cdc15a4783
7 changed files with 74 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
alc/alu.cpp
View File

@ -103,8 +103,8 @@ struct BSincTag;
struct FastBSincTag; struct FastBSincTag;
static_assert(!(MAX_RESAMPLER_PADDING&1) && MAX_RESAMPLER_PADDING >= BSINC_POINTS_MAX, static_assert(MAX_RESAMPLER_PADDING >= BSincPointsMax, "MAX_RESAMPLER_PADDING is too small");
"MAX_RESAMPLER_PADDING is not a multiple of two, or is too small"); static_assert(!(MAX_RESAMPLER_PADDING&1), "MAX_RESAMPLER_PADDING is not a multiple of two");
namespace { namespace {
@ -174,13 +174,13 @@ inline HrtfDirectMixerFunc SelectHrtfMixer(void)
inline void BsincPrepare(const ALuint increment, BsincState *state, const BSincTable *table) 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}; float sf{0.0f};
if(increment > FRACTIONONE) if(increment > FRACTIONONE)
{ {
sf = FRACTIONONE / static_cast<float>(increment); 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); si = float2uint(sf);
/* The interpolation factor is fit to this diagonally-symmetric curve /* The interpolation factor is fit to this diagonally-symmetric curve
* to reduce the transition ripple caused by interpolating different * to reduce the transition ripple caused by interpolating different

15
alc/bsinc_defs.h
View File

@ -2,12 +2,15 @@
#define BSINC_DEFS_H #define BSINC_DEFS_H
/* The number of distinct scale and phase intervals within the filter table. */ /* The number of distinct scale and phase intervals within the filter table. */
#define BSINC_SCALE_BITS 4 constexpr unsigned int BSincScaleBits{4};
#define BSINC_SCALE_COUNT (1<<BSINC_SCALE_BITS) constexpr unsigned int BSincScaleCount{1 << BSincScaleBits};
#define BSINC_PHASE_BITS 5 constexpr unsigned int BSincPhaseBits{5};
#define BSINC_PHASE_COUNT (1<<BSINC_PHASE_BITS) constexpr unsigned int BSincPhaseCount{1 << BSincPhaseBits};
/* The maximum number of sample points for the bsinc filters. */ /* The maximum number of sample points for the bsinc filters. The max points
#define BSINC_POINTS_MAX 48 * 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 */ #endif /* BSINC_DEFS_H */

89
alc/bsinc_tables.cpp
View File

@ -15,14 +15,7 @@
namespace { namespace {
/* The max points includes the doubling for downsampling, so the maximum number using uint = unsigned int;
* 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};
/* This is the normalized cardinal sine (sinc) function. /* 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. /* Calculates the (normalized frequency) transition width of the Kaiser window.
* Rejection is in dB. * 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) 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 */ /* This enforces a minimum rejection of just above 21.18dB */
return 5.79 / (order * al::MathDefs<double>::Tau()); 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) constexpr double CalcKaiserBeta(const double rejection)
{ {
if(rejection > 50.0) if(rejection > 50.0)
return 0.1102 * (rejection-8.7); return 0.1102 * (rejection-8.7);
else if(rejection >= 21.0) 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; return 0.0;
} }
@ -116,10 +109,10 @@ struct BSincHeader {
double scaleRange{}; double scaleRange{};
double besseli_0_beta{}; double besseli_0_beta{};
int a[BSINC_SCALE_COUNT]{}; uint a[BSincScaleCount]{};
int total_size{}; uint total_size{};
constexpr BSincHeader(int Rejection, int Order) noexcept constexpr BSincHeader(uint Rejection, uint Order) noexcept
{ {
width = CalcKaiserWidth(Rejection, Order); width = CalcKaiserWidth(Rejection, Order);
beta = CalcKaiserBeta(Rejection); beta = CalcKaiserBeta(Rejection);
@ -127,15 +120,15 @@ struct BSincHeader {
scaleRange = 1.0 - scaleBase; scaleRange = 1.0 - scaleBase;
besseli_0_beta = BesselI_0(beta); besseli_0_beta = BesselI_0(beta);
int num_points{Order+1}; uint num_points{Order+1};
for(int si{0};si < BSincScaleCount;++si) for(uint si{0};si < BSincScaleCount;++si)
{ {
const double scale{scaleBase + (scaleRange * si / (BSincScaleCount - 1))}; const double scale{scaleBase + (scaleRange * si / (BSincScaleCount-1))};
const int a_{std::min(static_cast<int>(num_points / 2.0 / scale), num_points)}; const uint a_{std::min(static_cast<uint>(num_points / 2.0 / scale), num_points)};
const int m{2 * a_}; const uint m{2 * a_};
a[si] = 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 /* Calculate the Kaiser-windowed Sinc filter coefficients for each
* scale and phase index. * 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 uint m{hdr.a[si] * 2};
const int o{BSincPointsHalf - (m/2)}; const size_t o{(BSincPointsMax-m) / 2};
const int l{hdr.a[si] - 1}; const double scale{hdr.scaleBase + (hdr.scaleRange * si / (BSincScaleCount-1))};
const int a{hdr.a[si]};
const double scale{hdr.scaleBase + (hdr.scaleRange * si / (BSincScaleCount - 1))};
const double cutoff{scale - (hdr.scaleBase * std::max(0.5, scale) * 2.0)}; 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 /* Do one extra phase index so that the phase delta has a proper
* target for its last index. * 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})}; 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}; const double x{i - phase};
filter[si][pi][o+i] = Kaiser(hdr.beta, x/a, hdr.besseli_0_beta) * cutoff * 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}; 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 size_t m{((hdr.a[si]*2) + 3) & ~3u};
const int o{BSincPointsHalf - (m/2)}; 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 /* Write out the filter. Also calculate and write out the phase
* and scale deltas. * 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]); mTable[idx++] = static_cast<float>(filter[si][pi][o+i]);
/* Linear interpolation between phases is simplified by pre- /* Linear interpolation between phases is simplified by pre-
* calculating the delta (b - a) in: x = a + f (b - a) * 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]}; const double phDelta{filter[si][pi+1][o+i] - filter[si][pi][o+i]};
mTable[idx++] = static_cast<float>(phDelta); mTable[idx++] = static_cast<float>(phDelta);
@ -217,7 +210,7 @@ struct BSincFilterArray {
* Given a difference in points between scales, the destination * Given a difference in points between scales, the destination
* points will be 0, thus: x = a + f (-a) * 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]}; const double scDelta{filter[si+1][pi][o+i] - filter[si][pi][o+i]};
mTable[idx++] = static_cast<float>(scDelta); mTable[idx++] = static_cast<float>(scDelta);
@ -226,7 +219,7 @@ struct BSincFilterArray {
/* This last simplification is done to complete the bilinear /* This last simplification is done to complete the bilinear
* equation for the combination of phase and scale. * 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]) - 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])}; (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 /* The last scale index doesn't have any scale or scale-phase
* deltas. * deltas.
*/ */
const unsigned int si{BSincScaleCount - 1}; constexpr size_t si{BSincScaleCount-1};
const int m{((hdr.a[si]*2) + 3) & ~3}; const size_t m{((hdr.a[si]*2) + 3) & ~3u};
const int o{BSincPointsHalf - (m/2)}; 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]); 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]}; const double phDelta{filter[si][pi+1][o+i] - filter[si][pi][o+i]};
mTable[idx++] = static_cast<float>(phDelta); 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; mTable[idx++] = 0.0f;
for(int i{0};i < m;++i) for(size_t i{0};i < m;++i)
mTable[idx++] = 0.0f; mTable[idx++] = 0.0f;
} }
} }
@ -273,10 +266,10 @@ constexpr BSincTable GenerateBSincTable(const BSincHeader &hdr, const float *tab
BSincTable ret{}; BSincTable ret{};
ret.scaleBase = static_cast<float>(hdr.scaleBase); ret.scaleBase = static_cast<float>(hdr.scaleBase);
ret.scaleRange = static_cast<float>(1.0 / hdr.scaleRange); ret.scaleRange = static_cast<float>(1.0 / hdr.scaleRange);
for(int i{0};i < BSincScaleCount;++i) for(size_t i{0};i < BSincScaleCount;++i)
ret.m[i] = static_cast<unsigned int>(((hdr.a[i]*2) + 3) & ~3); ret.m[i] = ((hdr.a[i]*2) + 3) & ~3u;
ret.filterOffset[0] = 0; 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.filterOffset[i] = ret.filterOffset[i-1] + ret.m[i-1]*4*BSincPhaseCount;
ret.Tab = tab; ret.Tab = tab;
return ret; return ret;

4
alc/bsinc_tables.h
View File

@ -6,8 +6,8 @@
struct BSincTable { struct BSincTable {
float scaleBase, scaleRange; float scaleBase, scaleRange;
unsigned int m[BSINC_SCALE_COUNT]; unsigned int m[BSincScaleCount];
unsigned int filterOffset[BSINC_SCALE_COUNT]; unsigned int filterOffset[BSincScaleCount];
const float *Tab; const float *Tab;
}; };

12
alc/mixer/mixer_c.cpp
View File

@ -21,8 +21,8 @@ struct FastBSincTag;
namespace { namespace {
#define FRAC_PHASE_BITDIFF (FRACTIONBITS - BSINC_PHASE_BITS) constexpr ALuint FracPhaseBitDiff{FRACTIONBITS - BSincPhaseBits};
#define FRAC_PHASE_DIFFONE (1<<FRAC_PHASE_BITDIFF) constexpr ALuint FracPhaseDiffOne{1 << FracPhaseBitDiff};
inline float do_point(const InterpState&, const float *RESTRICT vals, const ALuint) inline float do_point(const InterpState&, const float *RESTRICT vals, const ALuint)
{ return vals[0]; } { 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}; const size_t m{istate.bsinc.m};
// Calculate the phase index and factor. // Calculate the phase index and factor.
const ALuint pi{frac >> FRAC_PHASE_BITDIFF}; const ALuint pi{frac >> FracPhaseBitDiff};
const float pf{static_cast<float>(frac & (FRAC_PHASE_DIFFONE-1)) * (1.0f/FRAC_PHASE_DIFFONE)}; const float pf{static_cast<float>(frac & (FracPhaseDiffOne-1)) * (1.0f/FracPhaseDiffOne)};
const float *fil{istate.bsinc.filter + m*pi*4}; const float *fil{istate.bsinc.filter + m*pi*4};
const float *phd{fil + m}; 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}; const size_t m{istate.bsinc.m};
// Calculate the phase index and factor. // Calculate the phase index and factor.
const ALuint pi{frac >> FRAC_PHASE_BITDIFF}; const ALuint pi{frac >> FracPhaseBitDiff};
const float pf{static_cast<float>(frac & (FRAC_PHASE_DIFFONE-1)) * (1.0f/FRAC_PHASE_DIFFONE)}; const float pf{static_cast<float>(frac & (FracPhaseDiffOne-1)) * (1.0f/FracPhaseDiffOne)};
const float *fil{istate.bsinc.filter + m*pi*4}; const float *fil{istate.bsinc.filter + m*pi*4};
const float *phd{fil + m}; const float *phd{fil + m};

14
alc/mixer/mixer_neon.cpp
View File

@ -21,8 +21,8 @@ struct FastBSincTag;
namespace { namespace {
#define FRAC_PHASE_BITDIFF (FRACTIONBITS - BSINC_PHASE_BITS) constexpr ALuint FracPhaseBitDiff{FRACTIONBITS - BSincPhaseBits};
#define FRAC_PHASE_DIFFONE (1<<FRAC_PHASE_BITDIFF) constexpr ALuint FracPhaseDiffOne{1 << FracPhaseBitDiff};
inline void ApplyCoeffs(float2 *RESTRICT Values, const uint_fast32_t IrSize, inline void ApplyCoeffs(float2 *RESTRICT Values, const uint_fast32_t IrSize,
const HrirArray &Coeffs, const float left, const float right) 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) for(float &out_sample : dst)
{ {
// Calculate the phase index and factor. // Calculate the phase index and factor.
const ALuint pi{frac >> FRAC_PHASE_BITDIFF}; const ALuint pi{frac >> FracPhaseBitDiff};
const float pf{static_cast<float>(frac & (FRAC_PHASE_DIFFONE-1)) * const float pf{static_cast<float>(frac & (FracPhaseDiffOne-1)) * (1.0f/FracPhaseDiffOne)};
(1.0f/FRAC_PHASE_DIFFONE)};
// Apply the scale and phase interpolated filter. // Apply the scale and phase interpolated filter.
float32x4_t r4{vdupq_n_f32(0.0f)}; 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) for(float &out_sample : dst)
{ {
// Calculate the phase index and factor. // Calculate the phase index and factor.
const ALuint pi{frac >> FRAC_PHASE_BITDIFF}; const ALuint pi{frac >> FracPhaseBitDiff};
const float pf{static_cast<float>(frac & (FRAC_PHASE_DIFFONE-1)) * const float pf{static_cast<float>(frac & (FracPhaseDiffOne-1)) * (1.0f/FracPhaseDiffOne)};
(1.0f/FRAC_PHASE_DIFFONE)};
// Apply the phase interpolated filter. // Apply the phase interpolated filter.
float32x4_t r4{vdupq_n_f32(0.0f)}; float32x4_t r4{vdupq_n_f32(0.0f)};

14
alc/mixer/mixer_sse.cpp
View File

@ -20,8 +20,8 @@ struct FastBSincTag;
namespace { namespace {
#define FRAC_PHASE_BITDIFF (FRACTIONBITS - BSINC_PHASE_BITS) constexpr ALuint FracPhaseBitDiff{FRACTIONBITS - BSincPhaseBits};
#define FRAC_PHASE_DIFFONE (1<<FRAC_PHASE_BITDIFF) constexpr ALuint FracPhaseDiffOne{1 << FracPhaseBitDiff};
#define MLA4(x, y, z) _mm_add_ps(x, _mm_mul_ps(y, z)) #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) for(float &out_sample : dst)
{ {
// Calculate the phase index and factor. // Calculate the phase index and factor.
const ALuint pi{frac >> FRAC_PHASE_BITDIFF}; const ALuint pi{frac >> FracPhaseBitDiff};
const float pf{static_cast<float>(frac & (FRAC_PHASE_DIFFONE-1)) * const float pf{static_cast<float>(frac & (FracPhaseDiffOne-1)) * (1.0f/FracPhaseDiffOne)};
(1.0f/FRAC_PHASE_DIFFONE)};
// Apply the scale and phase interpolated filter. // Apply the scale and phase interpolated filter.
__m128 r4{_mm_setzero_ps()}; __m128 r4{_mm_setzero_ps()};
@ -133,9 +132,8 @@ const float *Resample_<FastBSincTag,SSETag>(const InterpState *state, const floa
for(float &out_sample : dst) for(float &out_sample : dst)
{ {
// Calculate the phase index and factor. // Calculate the phase index and factor.
const ALuint pi{frac >> FRAC_PHASE_BITDIFF}; const ALuint pi{frac >> FracPhaseBitDiff};
const float pf{static_cast<float>(frac & (FRAC_PHASE_DIFFONE-1)) * const float pf{static_cast<float>(frac & (FracPhaseDiffOne-1)) * (1.0f/FracPhaseDiffOne)};
(1.0f/FRAC_PHASE_DIFFONE)};
// Apply the phase interpolated filter. // Apply the phase interpolated filter.
__m128 r4{_mm_setzero_ps()}; __m128 r4{_mm_setzero_ps()};