mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-07-11 14:44:36 +00:00
Initial commit
added libraries: opus flac libsndfile updated: libvorbis libogg openal - Everything works as expected for now. Bare in mind libsndfile needed the check for whether or not it could find the xiph libraries removed in order for this to work.
This commit is contained in:
marauder2k7
parent
05a083ca6f
commit
a745fc3757
1954 changed files with 431332 additions and 21037 deletions
|
|
@ -7,6 +7,7 @@
|
|||
#include <cassert>
|
||||
#include <cmath>
|
||||
#include <cstddef>
|
||||
#include <functional>
|
||||
#include <utility>
|
||||
|
||||
#include "albit.h"
|
||||
|
|
@ -20,12 +21,6 @@ namespace {
|
|||
using ushort = unsigned short;
|
||||
using ushort2 = std::pair<ushort,ushort>;
|
||||
|
||||
/* Because std::array doesn't have constexpr non-const accessors in C++14. */
|
||||
template<typename T, size_t N>
|
||||
struct our_array {
|
||||
T mData[N];
|
||||
};
|
||||
|
||||
constexpr size_t BitReverseCounter(size_t log2_size) noexcept
|
||||
{
|
||||
/* Some magic math that calculates the number of swaps needed for a
|
||||
|
|
@ -34,51 +29,54 @@ constexpr size_t BitReverseCounter(size_t log2_size) noexcept
|
|||
return (1u<<(log2_size-1)) - (1u<<((log2_size-1u)/2u));
|
||||
}
|
||||
|
||||
|
||||
template<size_t N>
|
||||
constexpr auto GetBitReverser() noexcept
|
||||
{
|
||||
struct BitReverser {
|
||||
static_assert(N <= sizeof(ushort)*8, "Too many bits for the bit-reversal table.");
|
||||
|
||||
our_array<ushort2, BitReverseCounter(N)> ret{};
|
||||
const size_t fftsize{1u << N};
|
||||
size_t ret_i{0};
|
||||
ushort2 mData[BitReverseCounter(N)]{};
|
||||
|
||||
/* Bit-reversal permutation applied to a sequence of fftsize items. */
|
||||
for(size_t idx{1u};idx < fftsize-1;++idx)
|
||||
constexpr BitReverser()
|
||||
{
|
||||
size_t revidx{0u}, imask{idx};
|
||||
for(size_t i{0};i < N;++i)
|
||||
{
|
||||
revidx = (revidx<<1) | (imask&1);
|
||||
imask >>= 1;
|
||||
}
|
||||
const size_t fftsize{1u << N};
|
||||
size_t ret_i{0};
|
||||
|
||||
if(idx < revidx)
|
||||
/* Bit-reversal permutation applied to a sequence of fftsize items. */
|
||||
for(size_t idx{1u};idx < fftsize-1;++idx)
|
||||
{
|
||||
ret.mData[ret_i].first = static_cast<ushort>(idx);
|
||||
ret.mData[ret_i].second = static_cast<ushort>(revidx);
|
||||
++ret_i;
|
||||
size_t revidx{0u}, imask{idx};
|
||||
for(size_t i{0};i < N;++i)
|
||||
{
|
||||
revidx = (revidx<<1) | (imask&1);
|
||||
imask >>= 1;
|
||||
}
|
||||
|
||||
if(idx < revidx)
|
||||
{
|
||||
mData[ret_i].first = static_cast<ushort>(idx);
|
||||
mData[ret_i].second = static_cast<ushort>(revidx);
|
||||
++ret_i;
|
||||
}
|
||||
}
|
||||
assert(ret_i == al::size(mData));
|
||||
}
|
||||
assert(ret_i == al::size(ret.mData));
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
/* These bit-reversal swap tables support up to 10-bit indices (1024 elements),
|
||||
* which is the largest used by OpenAL Soft's filters and effects. Larger FFT
|
||||
* requests, used by some utilities where performance is less important, will
|
||||
* use a slower table-less path.
|
||||
*/
|
||||
constexpr auto BitReverser2 = GetBitReverser<2>();
|
||||
constexpr auto BitReverser3 = GetBitReverser<3>();
|
||||
constexpr auto BitReverser4 = GetBitReverser<4>();
|
||||
constexpr auto BitReverser5 = GetBitReverser<5>();
|
||||
constexpr auto BitReverser6 = GetBitReverser<6>();
|
||||
constexpr auto BitReverser7 = GetBitReverser<7>();
|
||||
constexpr auto BitReverser8 = GetBitReverser<8>();
|
||||
constexpr auto BitReverser9 = GetBitReverser<9>();
|
||||
constexpr auto BitReverser10 = GetBitReverser<10>();
|
||||
constexpr al::span<const ushort2> gBitReverses[11]{
|
||||
constexpr BitReverser<2> BitReverser2{};
|
||||
constexpr BitReverser<3> BitReverser3{};
|
||||
constexpr BitReverser<4> BitReverser4{};
|
||||
constexpr BitReverser<5> BitReverser5{};
|
||||
constexpr BitReverser<6> BitReverser6{};
|
||||
constexpr BitReverser<7> BitReverser7{};
|
||||
constexpr BitReverser<8> BitReverser8{};
|
||||
constexpr BitReverser<9> BitReverser9{};
|
||||
constexpr BitReverser<10> BitReverser10{};
|
||||
constexpr std::array<al::span<const ushort2>,11> gBitReverses{{
|
||||
{}, {},
|
||||
BitReverser2.mData,
|
||||
BitReverser3.mData,
|
||||
|
|
@ -89,11 +87,13 @@ constexpr al::span<const ushort2> gBitReverses[11]{
|
|||
BitReverser8.mData,
|
||||
BitReverser9.mData,
|
||||
BitReverser10.mData
|
||||
};
|
||||
}};
|
||||
|
||||
} // namespace
|
||||
|
||||
void complex_fft(const al::span<std::complex<double>> buffer, const double sign)
|
||||
template<typename Real>
|
||||
std::enable_if_t<std::is_floating_point<Real>::value>
|
||||
complex_fft(const al::span<std::complex<Real>> buffer, const al::type_identity_t<Real> sign)
|
||||
{
|
||||
const size_t fftsize{buffer.size()};
|
||||
/* Get the number of bits used for indexing. Simplifies bit-reversal and
|
||||
|
|
@ -101,7 +101,7 @@ void complex_fft(const al::span<std::complex<double>> buffer, const double sign)
|
|||
*/
|
||||
const size_t log2_size{static_cast<size_t>(al::countr_zero(fftsize))};
|
||||
|
||||
if(unlikely(log2_size >= al::size(gBitReverses)))
|
||||
if(log2_size >= gBitReverses.size()) UNLIKELY
|
||||
{
|
||||
for(size_t idx{1u};idx < fftsize-1;++idx)
|
||||
{
|
||||
|
|
@ -120,21 +120,21 @@ void complex_fft(const al::span<std::complex<double>> buffer, const double sign)
|
|||
std::swap(buffer[rev.first], buffer[rev.second]);
|
||||
|
||||
/* Iterative form of Danielson-Lanczos lemma */
|
||||
const double pi{al::numbers::pi * sign};
|
||||
const Real pi{al::numbers::pi_v<Real> * sign};
|
||||
size_t step2{1u};
|
||||
for(size_t i{0};i < log2_size;++i)
|
||||
{
|
||||
const double arg{pi / static_cast<double>(step2)};
|
||||
const Real arg{pi / static_cast<Real>(step2)};
|
||||
|
||||
/* TODO: Would std::polar(1.0, arg) be any better? */
|
||||
const std::complex<double> w{std::cos(arg), std::sin(arg)};
|
||||
std::complex<double> u{1.0, 0.0};
|
||||
const std::complex<Real> w{std::cos(arg), std::sin(arg)};
|
||||
std::complex<Real> u{1.0, 0.0};
|
||||
const size_t step{step2 << 1};
|
||||
for(size_t j{0};j < step2;j++)
|
||||
{
|
||||
for(size_t k{j};k < fftsize;k+=step)
|
||||
{
|
||||
std::complex<double> temp{buffer[k+step2] * u};
|
||||
std::complex<Real> temp{buffer[k+step2] * u};
|
||||
buffer[k+step2] = buffer[k] - temp;
|
||||
buffer[k] += temp;
|
||||
}
|
||||
|
|
@ -148,6 +148,8 @@ void complex_fft(const al::span<std::complex<double>> buffer, const double sign)
|
|||
|
||||
void complex_hilbert(const al::span<std::complex<double>> buffer)
|
||||
{
|
||||
using namespace std::placeholders;
|
||||
|
||||
inverse_fft(buffer);
|
||||
|
||||
const double inverse_size = 1.0/static_cast<double>(buffer.size());
|
||||
|
|
@ -156,11 +158,14 @@ void complex_hilbert(const al::span<std::complex<double>> buffer)
|
|||
|
||||
*bufiter *= inverse_size; ++bufiter;
|
||||
bufiter = std::transform(bufiter, halfiter, bufiter,
|
||||
[inverse_size](const std::complex<double> &c) -> std::complex<double>
|
||||
{ return c * (2.0*inverse_size); });
|
||||
[scale=inverse_size*2.0](std::complex<double> d){ return d * scale; });
|
||||
*bufiter *= inverse_size; ++bufiter;
|
||||
|
||||
std::fill(bufiter, buffer.end(), std::complex<double>{});
|
||||
|
||||
forward_fft(buffer);
|
||||
}
|
||||
|
||||
|
||||
template void complex_fft<>(const al::span<std::complex<float>> buffer, const float sign);
|
||||
template void complex_fft<>(const al::span<std::complex<double>> buffer, const double sign);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue