// IDCTOrthogonal returns Inverse DCT (DCT-III) coefficients given a input
// signal.
func IDCTOrthogonal(dctCoef []float64) []float64 {
n := len(dctCoef)
nh := n / 2
array := make([]complex128, n)
theta := math.Pi / (2.0 * float64(n))
c0 := math.Sqrt(1.0 / float64(n))
c1 := math.Sqrt(2.0 / float64(n))
// -1/4 Shift
for k := 1; k < nh; k++ {
w := cmplx.Exp(complex(0, float64(k)*theta))
wCont := complex(imag(w), real(w))
array[k] = w * complex(c1*dctCoef[k], 0)
array[n-k] = wCont * complex(c1*dctCoef[n-k], 0)
}
array[0] = complex(c0*dctCoef[0], 0)
array[nh] = complex(c1*dctCoef[nh], 0) *
cmplx.Exp(complex(0, float64(nh)*theta))
y := fft.IFFT(array)
x := make([]float64, n)
for i := 0; i < nh; i++ {
x[2*i] = float64(n) * real(y[i])
x[2*i+1] = float64(n) * real(y[n-1-i])
}
return x
}
func ExtIFFT_C(samples vlib.VectorC, N int) vlib.VectorC {
y := vlib.VectorC(fft.IFFT(samples))
y = y.Scale(math.Sqrt(1.0 / float64(N)))
return y
}
// ISTFT performs invere STFT signal reconstruction and returns reconstructed
// signal.
func (s *STFT) ISTFT(spectrogram [][]complex128) []float64 {
frameLen := len(spectrogram[0])
numFrames := len(spectrogram)
reconstructedSignal := make([]float64, frameLen+numFrames*s.FrameShift)
// Griffin's method
windowSum := make([]float64, len(reconstructedSignal))
for i := 0; i < numFrames; i++ {
buf := fft.IFFT(spectrogram[i])
index := 0
for t := i * s.FrameShift; t < i*s.FrameShift+frameLen; t++ {
reconstructedSignal[t] += real(buf[index]) * s.Window[index]
windowSum[t] += s.Window[index] * s.Window[index]
index++
}
}
// Normalize by window
for n := range reconstructedSignal {
if windowSum[n] > 1.0e-21 {
reconstructedSignal[n] /= windowSum[n]
}
}
return reconstructedSignal
}
func XCorrFFT(x1, x2 []float64, circular bool) []float64 {
// zero padding.
ftlength := len(x1)
if !circular {
length := len(x1) * 2
var i uint32 = 1
for ftlength < length {
ftlength = 1 << i
i++
}
}
datax1 := make([]complex128, ftlength)
datax2 := make([]complex128, ftlength)
for i := 0; i < len(x1); i++ {
datax1[i] = complex(x2[i%len(x2)], 0)
datax2[i] = complex(x1[i%len(x1)], 0)
}
v1 := fft.FFT(datax1)
v2 := fft.FFT(datax2)
temp := []complex128{}
for i := 0; i < len(v1); i++ {
v := v1[i] * cmplx.Conj(v2[i])
temp = append(temp, v)
}
v3 := fft.IFFT(temp)
res := []float64{}
for i := 0; i < len(x1); i++ {
res = append(res, real(v3[i]))
}
return res
}
func (cqi *CQInverse) processOctaveColumn(octave int, column []complex128) {
// 3. For each taller column, take the product with the inverse CQ
// kernel (which is the conjugate of the forward kernel) and
// perform an inverse FFT
bpo := cqi.kernel.Properties.binsPerOctave
apf := cqi.kernel.Properties.atomsPerFrame
fftSize := cqi.kernel.Properties.fftSize
if len(column) != bpo*apf {
fmt.Printf("Error: column in octave %d has size %d, required = %d * %d = %d\n",
octave, len(column), bpo, apf, bpo*apf)
panic("Invalid argument to inverse processOctaveColumn")
}
transformed := cqi.kernel.ProcessInverse(column)
// For inverse real transforms, force symmetric conjugate representation first.
for i := fftSize/2 + 1; i < fftSize; i++ {
transformed[i] = cmplx.Conj(transformed[fftSize-i])
}
inverse := fft.IFFT(transformed)
cqi.overlapAddAndResample(octave, realParts(inverse))
}
