curioustorvald/Terrarum
1
0
Fork 0
mirror of https://github.com/curioustorvald/Terrarum.git synced 2026-06-16 21:44:05 +09:00
Code Issues Packages Projects Releases Wiki Activity

removing unused libs

Browse Source
This commit is contained in:
minjaesong
2024-01-10 03:59:10 +09:00
parent 537968bb80
commit 724a92bc18
55 changed files with 44 additions and 616 deletions
Download Patch File Download Diff File Expand all files Collapse all files

303
src/net/torvald/terrarum/audio/FFT.kt
View File

@@ -2,8 +2,6 @@ package net.torvald.terrarum.audio
import com.badlogic.gdx.utils.Disposable
import net.torvald.terrarum.App
import org.apache.commons.math3.transform.DftNormalization
import org.apache.commons.math3.transform.TransformType
import org.jtransforms.fft.FloatFFT_1D
private val RE0 = 0
@@ -65,7 +63,7 @@ private val mulBuf = FloatArray(2)
}
/**
* Modification of the code form JDSP and Apache Commons Math
* Helper object to call JTransforms
*
* Created by minjaesong on 2023-11-25.
*/
@@ -86,57 +84,13 @@ object FFT: Disposable {
init {
// Loader.load(org.bytedeco.fftw.global.fftw3::class.java)
App.disposables.add(this)
}
/*private val reLock = ReentrantLock(true)
private fun getForwardPlan(n: Int, inn: FloatArray, out: FloatArray): fftwf_plan {
return fftwf_plan_dft_1d(n, inn, out, FFTW_FORWARD, FFTW_ESTIMATE)
}
private fun getBackwardPlan(n: Int, inn: FloatArray, out: FloatArray): fftwf_plan {
return fftwf_plan_dft_1d(n, inn, out, FFTW_BACKWARD, FFTW_ESTIMATE)
}
private fun destroyPlan(plan: fftwf_plan) {
fftwf_destroy_plan(plan)
}*/
override fun dispose() {
}
// org.apache.commons.math3.transform.FastFouriesTransformer.java:370
fun fft(signal0: FloatArray): ComplexArray {
// val im = FloatArray(signal0.size)
// transformInPlace(signal0, im, signal0.size, DftNormalization.STANDARD, TransformType.FORWARD)
// return ComplexArray(FloatArray(signal0.size) { if (it % 2 == 0) signal0[it / 2] else im[it / 2] })
// USING FFTW //
/*lateinit var retObj: ComplexArray
reLock.lock {
fftw_init_threads()
val signal = FloatArray(2 * signal0.size)
val result = FloatArray(2 * signal0.size)
val plan = getForwardPlan(signal0.size, signal, result)
signal0.forEachIndexed { index, fl -> signal[index * 2] = fl }
fftwf_execute(plan)
retObj = ComplexArray(result)
destroyPlan(plan)
fftwf_cleanup_threads()
}
return retObj*/
// USING JTRANSFORMS //
val signal = FloatArray(signal0.size * 2) { if (it % 2 == 0) signal0[it / 2] else 0f }
ffts[signal0.size]!!.complexForward(signal)
return ComplexArray(signal)
@@ -151,36 +105,7 @@ object FFT: Disposable {
ffts[signal0.size]!!.complexForward(out.reim)
}
// org.apache.commons.math3.transform.FastFouriesTransformer.java:404
fun ifftAndGetReal(signal0: ComplexArray): FloatArray {
// val re = FloatArray(signal0.size) { signal0.reim[it * 2] }
// val im = FloatArray(signal0.size) { signal0.reim[it * 2 + 1] }
// transformInPlace(re, im, re.size, DftNormalization.STANDARD, TransformType.INVERSE)
// return re
// USING FFTW //
/*lateinit var re: FloatArray
reLock.lock {
fftw_init_threads()
val signal = signal0.reim
val result = FloatArray(2 * signal0.size)
val plan = getBackwardPlan(signal0.size, signal, result)
fftwf_execute(plan)
re = FloatArray(signal0.size) { result[it * 2] }
destroyPlan(plan)
fftwf_cleanup_threads()
}
return re*/
// USING JTRANSFORMS //
ffts[signal0.size]!!.complexInverse(signal0.reim, true)
return signal0.getReal()
}
@@ -191,230 +116,4 @@ object FFT: Disposable {
output[i] = signal0.reim[i * 2]
}
}
// org.apache.commons.math3.transform.FastFouriesTransformer.java:214
/**
* Computes the standard transform of the specified complex data. The
* computation is done in place. The input data is laid out as follows
* <ul>
* <li>{@code dataRI[0][i]} is the real part of the {@code i}-th data point,</li>
* <li>{@code dataRI[1][i]} is the imaginary part of the {@code i}-th data point.</li>
* </ul>
*
* @param dataRI the two dimensional array of real and imaginary parts of the data
* @param normalization the normalization to be applied to the transformed data
* @param type the type of transform (forward, inverse) to be performed
* @throws DimensionMismatchException if the number of rows of the specified
* array is not two, or the array is not rectangular
* @throws MathIllegalArgumentException if the number of data points is not
* a power of two
*/
private fun transformInPlace(dataR: FloatArray, dataI: FloatArray, n: Int, normalization: DftNormalization, type: TransformType) {
/*if (n == 1) {
return
}
else if (n == 2) {
val srcR0 = dataR[0]
val srcI0 = dataI[0]
val srcR1 = dataR[1]
val srcI1 = dataI[1]
// X_0 = x_0 + x_1
dataR[0] = srcR0 + srcR1
dataI[0] = srcI0 + srcI1
// X_1 = x_0 - x_1
dataR[1] = srcR0 - srcR1
dataI[1] = srcI0 - srcI1
normalizeTransformedData(dataRI, normalization, type)
return
}*/
bitReversalShuffle2(dataR, dataI)
// Do 4-term DFT.
if (type == TransformType.INVERSE) {
var i0 = 0
while (i0 < n) {
val i1 = i0 + 1
val i2 = i0 + 2
val i3 = i0 + 3
val srcR0 = dataR[i0]
val srcI0 = dataI[i0]
val srcR1 = dataR[i2]
val srcI1 = dataI[i2]
val srcR2 = dataR[i1]
val srcI2 = dataI[i1]
val srcR3 = dataR[i3]
val srcI3 = dataI[i3]
// 4-term DFT
// X_0 = x_0 + x_1 + x_2 + x_3
dataR[i0] = srcR0 + srcR1 + srcR2 + srcR3
dataI[i0] = srcI0 + srcI1 + srcI2 + srcI3
// X_1 = x_0 - x_2 + j * (x_3 - x_1)
dataR[i1] = srcR0 - srcR2 + (srcI3 - srcI1)
dataI[i1] = srcI0 - srcI2 + (srcR1 - srcR3)
// X_2 = x_0 - x_1 + x_2 - x_3
dataR[i2] = srcR0 - srcR1 + srcR2 - srcR3
dataI[i2] = srcI0 - srcI1 + srcI2 - srcI3
// X_3 = x_0 - x_2 + j * (x_1 - x_3)
dataR[i3] = srcR0 - srcR2 + (srcI1 - srcI3)
dataI[i3] = srcI0 - srcI2 + (srcR3 - srcR1)
i0 += 4
}
}
else {
var i0 = 0
while (i0 < n) {
val i1 = i0 + 1
val i2 = i0 + 2
val i3 = i0 + 3
val srcR0 = dataR[i0]
val srcI0 = dataI[i0]
val srcR1 = dataR[i2]
val srcI1 = dataI[i2]
val srcR2 = dataR[i1]
val srcI2 = dataI[i1]
val srcR3 = dataR[i3]
val srcI3 = dataI[i3]
// 4-term DFT
// X_0 = x_0 + x_1 + x_2 + x_3
dataR[i0] = srcR0 + srcR1 + srcR2 + srcR3
dataI[i0] = srcI0 + srcI1 + srcI2 + srcI3
// X_1 = x_0 - x_2 + j * (x_3 - x_1)
dataR[i1] = srcR0 - srcR2 + (srcI1 - srcI3)
dataI[i1] = srcI0 - srcI2 + (srcR3 - srcR1)
// X_2 = x_0 - x_1 + x_2 - x_3
dataR[i2] = srcR0 - srcR1 + srcR2 - srcR3
dataI[i2] = srcI0 - srcI1 + srcI2 - srcI3
// X_3 = x_0 - x_2 + j * (x_1 - x_3)
dataR[i3] = srcR0 - srcR2 + (srcI3 - srcI1)
dataI[i3] = srcI0 - srcI2 + (srcR1 - srcR3)
i0 += 4
}
}
var lastN0 = 4
var lastLogN0 = 2
while (lastN0 < n) {
val n0 = lastN0 shl 1
val logN0 = lastLogN0 + 1
val wSubN0R = W_SUB_N_R[logN0]
var wSubN0I = W_SUB_N_I[logN0]
if (type == TransformType.INVERSE) {
wSubN0I = -wSubN0I
}
// Combine even/odd transforms of size lastN0 into a transform of size N0 (lastN0 * 2).
var destEvenStartIndex = 0
while (destEvenStartIndex < n) {
val destOddStartIndex = destEvenStartIndex + lastN0
var wSubN0ToRR = 1f
var wSubN0ToRI = 0f
for (r in 0 until lastN0) {
val grR = dataR[destEvenStartIndex + r]
val grI = dataI[destEvenStartIndex + r]
val hrR = dataR[destOddStartIndex + r]
val hrI = dataI[destOddStartIndex + r]
// dest[destEvenStartIndex + r] = Gr + WsubN0ToR * Hr
dataR[destEvenStartIndex + r] = grR + wSubN0ToRR * hrR - wSubN0ToRI * hrI
dataI[destEvenStartIndex + r] = grI + wSubN0ToRR * hrI + wSubN0ToRI * hrR
// dest[destOddStartIndex + r] = Gr - WsubN0ToR * Hr
dataR[destOddStartIndex + r] = grR - (wSubN0ToRR * hrR - wSubN0ToRI * hrI)
dataI[destOddStartIndex + r] = grI - (wSubN0ToRR * hrI + wSubN0ToRI * hrR)
// WsubN0ToR *= WsubN0R
val nextWsubN0ToRR = wSubN0ToRR * wSubN0R - wSubN0ToRI * wSubN0I
val nextWsubN0ToRI = wSubN0ToRR * wSubN0I + wSubN0ToRI * wSubN0R
wSubN0ToRR = nextWsubN0ToRR
wSubN0ToRI = nextWsubN0ToRI
}
destEvenStartIndex += n0
}
lastN0 = n0
lastLogN0 = logN0
}
normalizeTransformedData(dataR, dataI, n, normalization, type)
}
/**
* Applies the proper normalization to the specified transformed data.
*
* @param dataRI the unscaled transformed data
* @param normalization the normalization to be applied
* @param type the type of transform (forward, inverse) which resulted in the specified data
*/
private fun normalizeTransformedData(
dataR: FloatArray, dataI: FloatArray, n: Int,
normalization: DftNormalization, type: TransformType
) {
// assert(dataI.size == n)
// when (normalization) {
// DftNormalization.STANDARD ->
if (type == TransformType.INVERSE) {
val scaleFactor = 1f / n.toFloat()
var i = 0
while (i < n) {
dataR[i] *= scaleFactor
dataI[i] *= scaleFactor
i++
}
}
/* DftNormalization.UNITARY -> {
val scaleFactor = (1.0 / FastMath.sqrt(n.toDouble())).toFloat()
var i = 0
while (i < n) {
dataR[i] *= scaleFactor
dataI[i] *= scaleFactor
i++
}
}
else -> throw MathIllegalStateException()
}*/
}
/**
* Performs identical index bit reversal shuffles on two arrays of identical
* size. Each element in the array is swapped with another element based on
* the bit-reversal of the index. For example, in an array with length 16,
* item at binary index 0011 (decimal 3) would be swapped with the item at
* binary index 1100 (decimal 12).
*
* @param a the first array to be shuffled
* @param b the second array to be shuffled
*/
private fun bitReversalShuffle2(a: FloatArray, b: FloatArray) {
val n = a.size
assert(b.size == n)
val halfOfN = n shr 1
var j = 0
for (i in 0 until n) {
if (i < j) {
// swap indices i & j
var temp = a[i]
a[i] = a[j]
a[j] = temp
temp = b[i]
b[i] = b[j]
b[j] = temp
}
var k = halfOfN
while (k in 1..j) {
j -= k
k = k shr 1
}
j += k
}
}
private val W_SUB_N_R = FFTConsts.W_SUB_N_R.map { it.toFloat() }.toFloatArray()
private val W_SUB_N_I = FFTConsts.W_SUB_N_I.map { it.toFloat() }.toFloatArray()
}

55
src/net/torvald/terrarum/audio/FFTConsts.java
View File

@@ -1,55 +0,0 @@
package net.torvald.terrarum.audio;
/**
* Created by minjaesong on 2023-11-25.
*/
public class FFTConsts {
// org.apache.commons.math3.transform.FastFouriesTransformer.java:58
/**
* {@code W_SUB_N_R[i]} is the real part of
* {@code exp(- 2 * i * pi / n)}:
* {@code W_SUB_N_R[i] = cos(2 * pi/ n)}, where {@code n = 2^i}.
*/
public static final double[] W_SUB_N_R =
{ 0x1.0p0, -0x1.0p0, 0x1.1a62633145c07p-54, 0x1.6a09e667f3bcdp-1
, 0x1.d906bcf328d46p-1, 0x1.f6297cff75cbp-1, 0x1.fd88da3d12526p-1, 0x1.ff621e3796d7ep-1
, 0x1.ffd886084cd0dp-1, 0x1.fff62169b92dbp-1, 0x1.fffd8858e8a92p-1, 0x1.ffff621621d02p-1
, 0x1.ffffd88586ee6p-1, 0x1.fffff62161a34p-1, 0x1.fffffd8858675p-1, 0x1.ffffff621619cp-1
, 0x1.ffffffd885867p-1, 0x1.fffffff62161ap-1, 0x1.fffffffd88586p-1, 0x1.ffffffff62162p-1
, 0x1.ffffffffd8858p-1, 0x1.fffffffff6216p-1, 0x1.fffffffffd886p-1, 0x1.ffffffffff621p-1
, 0x1.ffffffffffd88p-1, 0x1.fffffffffff62p-1, 0x1.fffffffffffd9p-1, 0x1.ffffffffffff6p-1
, 0x1.ffffffffffffep-1, 0x1.fffffffffffffp-1, 0x1.0p0, 0x1.0p0
, 0x1.0p0, 0x1.0p0, 0x1.0p0, 0x1.0p0
, 0x1.0p0, 0x1.0p0, 0x1.0p0, 0x1.0p0
, 0x1.0p0, 0x1.0p0, 0x1.0p0, 0x1.0p0
, 0x1.0p0, 0x1.0p0, 0x1.0p0, 0x1.0p0
, 0x1.0p0, 0x1.0p0, 0x1.0p0, 0x1.0p0
, 0x1.0p0, 0x1.0p0, 0x1.0p0, 0x1.0p0
, 0x1.0p0, 0x1.0p0, 0x1.0p0, 0x1.0p0
, 0x1.0p0, 0x1.0p0, 0x1.0p0 };
/**
* {@code W_SUB_N_I[i]} is the imaginary part of
* {@code exp(- 2 * i * pi / n)}:
* {@code W_SUB_N_I[i] = -sin(2 * pi/ n)}, where {@code n = 2^i}.
*/
public static final double[] W_SUB_N_I =
{ 0x1.1a62633145c07p-52, -0x1.1a62633145c07p-53, -0x1.0p0, -0x1.6a09e667f3bccp-1
, -0x1.87de2a6aea963p-2, -0x1.8f8b83c69a60ap-3, -0x1.917a6bc29b42cp-4, -0x1.91f65f10dd814p-5
, -0x1.92155f7a3667ep-6, -0x1.921d1fcdec784p-7, -0x1.921f0fe670071p-8, -0x1.921f8becca4bap-9
, -0x1.921faaee6472dp-10, -0x1.921fb2aecb36p-11, -0x1.921fb49ee4ea6p-12, -0x1.921fb51aeb57bp-13
, -0x1.921fb539ecf31p-14, -0x1.921fb541ad59ep-15, -0x1.921fb5439d73ap-16, -0x1.921fb544197ap-17
, -0x1.921fb544387bap-18, -0x1.921fb544403c1p-19, -0x1.921fb544422c2p-20, -0x1.921fb54442a83p-21
, -0x1.921fb54442c73p-22, -0x1.921fb54442cefp-23, -0x1.921fb54442d0ep-24, -0x1.921fb54442d15p-25
, -0x1.921fb54442d17p-26, -0x1.921fb54442d18p-27, -0x1.921fb54442d18p-28, -0x1.921fb54442d18p-29
, -0x1.921fb54442d18p-30, -0x1.921fb54442d18p-31, -0x1.921fb54442d18p-32, -0x1.921fb54442d18p-33
, -0x1.921fb54442d18p-34, -0x1.921fb54442d18p-35, -0x1.921fb54442d18p-36, -0x1.921fb54442d18p-37
, -0x1.921fb54442d18p-38, -0x1.921fb54442d18p-39, -0x1.921fb54442d18p-40, -0x1.921fb54442d18p-41
, -0x1.921fb54442d18p-42, -0x1.921fb54442d18p-43, -0x1.921fb54442d18p-44, -0x1.921fb54442d18p-45
, -0x1.921fb54442d18p-46, -0x1.921fb54442d18p-47, -0x1.921fb54442d18p-48, -0x1.921fb54442d18p-49
, -0x1.921fb54442d18p-50, -0x1.921fb54442d18p-51, -0x1.921fb54442d18p-52, -0x1.921fb54442d18p-53
, -0x1.921fb54442d18p-54, -0x1.921fb54442d18p-55, -0x1.921fb54442d18p-56, -0x1.921fb54442d18p-57
, -0x1.921fb54442d18p-58, -0x1.921fb54442d18p-59, -0x1.921fb54442d18p-60 };
}