quietlight/skraak_mcp - Change UE4TOOVXPEWPYVE5UEC6OTKYDUDVBTRV22HNOZ4XES2PWCBT24YAC

more spectro optimisation, inline fft

Created by quietlight on April 11, 2026

UE4TOOVXPEWPYVE5UEC6OTKYDUDVBTRV22HNOZ4XES2PWCBT24YAC

Dependencies

In channels

main

Change contents

Deletion in utils/spectrogram.go at line 7 [4.1]
B:BD[3.31] → [2.2606:2607]
Deletion in utils/spectrogram.go at line 9 [4.1]
B:BD[4.35] → [4.35:73]
```
	"github.com/madelynnblue/go-dsp/fft"
```

Deletion in utils/spectrogram.go at line 17 [4.1]

B:BD[2.2732] → [2.2732:2878]


func init() {
	// Pre-compute radix-2 factors for default window size to avoid lock contention under parallelism
	fft.EnsureRadix2Factors(512)
}

Insertion in utils/spectrogram.go at line 81 [4.1]

[2.3582]

[4.1436]


	// Pre-allocate scratch buffers (reused across all frames — zero allocs in loop)
	frameData := make([]float64, cfg.WindowSize)
	scratch := make([]complex128, cfg.WindowSize)
	framePower := make([]float64, numFreqBins)

Deletion in utils/spectrogram.go at line 88 [4.1]
B:BD[4.1454] → [5.8:54]
```
	frameData := make([]float64, cfg.WindowSize)
```

Replacement in utils/spectrogram.go at line 96 [4.1]

B:BD[4.1709] → [4.1709:1764]

		// Compute FFT
		fftResult := fft.FFTReal(frameData)

[4.1709]

[4.1764]

		// Compute power spectrum via inline FFT (zero allocations)
		PowerSpectrumFFT(frameData, framePower, scratch)

Replacement in utils/spectrogram.go at line 99 [4.1]

B:BD[4.1765] → [2.3583:3647]

		// Compute power spectrum (magnitude squared) into flat slice

[4.1765]

[6.165]

		// Copy power into flat matrix (freq bins x time frames layout)

Replacement in utils/spectrogram.go at line 101 [4.1]

∅:D[6.198] → [4.1856:1916]

B:BD[4.1856] → [4.1856:1916]

B:BD[4.1916] → [2.3648:3698]

			re := real(fftResult[bin])
			im := imag(fftResult[bin])
			powerFlat[bin*numFrames+frame] = re*re + im*im

[6.198]

[4.1977]

			powerFlat[bin*numFrames+frame] = framePower[bin]

File addition: fft_test.go (----------)

[7.1]

package utils
import (
	"math"
	"math/rand"
	"testing"
	"github.com/madelynnblue/go-dsp/fft"
)
// referencepower computes the power spectrum using go-dsp as ground truth.
func referencePower(samples []float64) []float64 {
	result := fft.FFTReal(samples)
	n := len(samples)
	numBins := n/2 + 1
	power := make([]float64, numBins)
	for k := 0; k < numBins; k++ {
		re := real(result[k])
		im := imag(result[k])
		power[k] = re*re + im*im
	}
	return power
}
func TestPowerSpectrumFFT_Sinusoid(t *testing.T) {
	// 512-point FFT of a pure 1kHz sine at 16kHz sample rate
	// Expected: peak at bin k = 1000 * 512 / 16000 = 32
	n := 512
	sampleRate := 16000.0
	freq := 1000.0
	samples := make([]float64, n)
	for i := range samples {
		samples[i] = math.Sin(2.0 * math.Pi * freq * float64(i) / sampleRate)
	}
	power := make([]float64, n/2+1)
	scratch := make([]complex128, n)
	PowerSpectrumFFT(samples, power, scratch)
	// Find peak bin
	maxBin := 0
	maxVal := 0.0
	for k, v := range power {
		if v > maxVal {
			maxVal = v
			maxBin = k
		}
	}
	expectedBin := int(freq * float64(n) / sampleRate)
	if maxBin != expectedBin {
		t.Errorf("peak at bin %d, expected %d", maxBin, expectedBin)
	}
	// Compare against reference
	ref := referencePower(samples)
	for k := range power {
		if math.Abs(power[k]-ref[k]) > 1e-6*math.Abs(ref[k])+1e-10 {
			t.Errorf("bin %d: got %g, ref %g", k, power[k], ref[k])
		}
	}
}
func TestPowerSpectrumFFT_Random(t *testing.T) {
	n := 512
	rng := rand.New(rand.NewSource(42))
	samples := make([]float64, n)
	for i := range samples {
		samples[i] = rng.Float64()*2 - 1
	}
	power := make([]float64, n/2+1)
	scratch := make([]complex128, n)
	PowerSpectrumFFT(samples, power, scratch)
	ref := referencePower(samples)
	for k := range power {
		relErr := math.Abs(power[k]-ref[k]) / (math.Abs(ref[k]) + 1e-15)
		if relErr > 1e-8 {
			t.Errorf("bin %d: got %g, ref %g (relErr=%g)", k, power[k], ref[k], relErr)
		}
	}
}
func TestPowerSpectrumFFT_DC(t *testing.T) {
	n := 512
	samples := make([]float64, n)
	for i := range samples {
		samples[i] = 1.0
	}
	power := make([]float64, n/2+1)
	scratch := make([]complex128, n)
	PowerSpectrumFFT(samples, power, scratch)
	ref := referencePower(samples)
	for k := range power {
		if math.Abs(power[k]-ref[k]) > 1e-6 {
			t.Errorf("bin %d: got %g, ref %g", k, power[k], ref[k])
		}
	}
	// DC bin should have all the energy
	if power[0] < power[1]*1000 {
		t.Errorf("DC bin should dominate: power[0]=%g, power[1]=%g", power[0], power[1])
	}
}
func TestPowerSpectrumFFT_Silence(t *testing.T) {
	n := 512
	samples := make([]float64, n)
	power := make([]float64, n/2+1)
	scratch := make([]complex128, n)
	PowerSpectrumFFT(samples, power, scratch)
	for k, v := range power {
		if v != 0 {
			t.Errorf("bin %d: expected 0, got %g", k, v)
		}
	}
}
func TestPowerSpectrumFFT_Impulse(t *testing.T) {
	n := 512
	samples := make([]float64, n)
	samples[0] = 1.0
	power := make([]float64, n/2+1)
	scratch := make([]complex128, n)
	PowerSpectrumFFT(samples, power, scratch)
	ref := referencePower(samples)
	for k := range power {
		if math.Abs(power[k]-ref[k]) > 1e-10 {
			t.Errorf("bin %d: got %g, ref %g", k, power[k], ref[k])
		}
	}
	// Impulse: flat power spectrum, all bins should be equal (= 1.0)
	for k, v := range power {
		if math.Abs(v-1.0) > 1e-10 {
			t.Errorf("bin %d: expected ~1.0, got %g", k, v)
		}
	}
}
func TestPowerSpectrumFFT_DifferentSizes(t *testing.T) {
	rng := rand.New(rand.NewSource(99))
	for _, n := range []int{2, 4, 8, 16, 64, 256, 1024} {
		samples := make([]float64, n)
		for i := range samples {
			samples[i] = rng.Float64()*2 - 1
		}
		power := make([]float64, n/2+1)
		scratch := make([]complex128, n)
		PowerSpectrumFFT(samples, power, scratch)
		ref := referencePower(samples)
		for k := range power {
			relErr := math.Abs(power[k]-ref[k]) / (math.Abs(ref[k]) + 1e-15)
			if relErr > 1e-8 {
				t.Errorf("n=%d bin %d: got %g, ref %g (relErr=%g)", n, k, power[k], ref[k], relErr)
			}
		}
	}
}
func BenchmarkPowerSpectrumFFT_512(b *testing.B) {
	n := 512
	rng := rand.New(rand.NewSource(42))
	samples := make([]float64, n)
	for i := range samples {
		samples[i] = rng.Float64()*2 - 1
	}
	power := make([]float64, n/2+1)
	scratch := make([]complex128, n)
	b.ResetTimer()
	for range b.N {
		PowerSpectrumFFT(samples, power, scratch)
	}
}
func BenchmarkGodsFFTReal_512(b *testing.B) {
	n := 512
	rng := rand.New(rand.NewSource(42))
	samples := make([]float64, n)
	for i := range samples {
		samples[i] = rng.Float64()*2 - 1
	}
	b.ResetTimer()
	for range b.N {
		fft.FFTReal(samples)
	}
}

File addition: fft.go (----------)

[7.1]

package utils
import (
	"math"
	"sync"
)
// FFT twiddle factors and bit-reversal tables, cached per size.
var (
	fftCacheMu sync.RWMutex
	fftCache   = map[int]*fftPlan{}
)
// fftPlan holds pre-computed data for a given FFT size.
type fftPlan struct {
	n       int
	twiddle []complex128 // twiddle factors: exp(-2*pi*i*k/N) for k=0..N/2-1
	bitrev  []int        // bit-reversal permutation table
}
// getFFFTPlan returns a cached FFT plan for the given size (must be power of 2).
func getFFTPlan(n int) *fftPlan {
	fftCacheMu.RLock()
	if p, ok := fftCache[n]; ok {
		fftCacheMu.RUnlock()
		return p
	}
	fftCacheMu.RUnlock()
	fftCacheMu.Lock()
	defer fftCacheMu.Unlock()
	if p, ok := fftCache[n]; ok {
		return p
	}
	p := &fftPlan{n: n}
	// Compute twiddle factors: exp(-2*pi*i*k/N) for k = 0..N/2-1
	p.twiddle = make([]complex128, n/2)
	for k := range p.twiddle {
		angle := -2.0 * math.Pi * float64(k) / float64(n)
		sin, cos := math.Sincos(angle)
		p.twiddle[k] = complex(cos, sin)
	}
	// Compute bit-reversal permutation
	bits := 0
	for v := n; v > 1; v >>= 1 {
		bits++
	}
	p.bitrev = make([]int, n)
	for i := range p.bitrev {
		p.bitrev[i] = reverseBitsN(i, bits)
	}
	fftCache[n] = p
	return p
}
// reverseBitsN reverses the lowest `bits` bits of v.
func reverseBitsN(v, bits int) int {
	var r int
	for i := 0; i < bits; i++ {
		r = (r << 1) | (v & 1)
		v >>= 1
	}
	return r
}
// PowerSpectrumFFT computes the power spectrum of a real-valued signal using radix-2 FFT.
//
// samples: real input of length N (must be power of 2, N >= 2)
// power:   output buffer of length >= N/2+1; receives |X[k]|^2 for k=0..N/2
// scratch: working buffer of length >= N; contents are overwritten
//
// All buffers are caller-provided to enable zero-allocation across repeated calls.
func PowerSpectrumFFT(samples []float64, power []float64, scratch []complex128) {
	n := len(samples)
	plan := getFFTPlan(n)
	// Bit-reversal copy: load real samples into scratch in bit-reversed order
	for i, j := range plan.bitrev {
		scratch[j] = complex(samples[i], 0)
	}
	// Iterative Cooley-Tukey butterfly (decimation-in-time)
	for size := 2; size <= n; size <<= 1 {
		half := size >> 1
		step := n / size // twiddle index step
		for start := 0; start < n; start += size {
			tw := 0
			for j := 0; j < half; j++ {
				u := scratch[start+j]
				v := scratch[start+j+half] * plan.twiddle[tw]
				scratch[start+j] = u + v
				scratch[start+j+half] = u - v
				tw += step
			}
		}
	}
	// Extract power spectrum: |X[k]|^2 = re^2 + im^2 for k = 0..N/2
	numBins := n/2 + 1
	for k := 0; k < numBins; k++ {
		re := real(scratch[k])
		im := imag(scratch[k])
		power[k] = re*re + im*im
	}
}

Insertion in tools/calls_clip.go at line 27 [9.2441]

[8.2701]

[9.3161]

	WavOnly   bool   `json:"wav_only" jsonschema:"Generate only WAV clips, skip spectrogram PNG generation"`

Replacement in tools/calls_clip.go at line 91 [9.2441]

B:BD[2.5448] → [2.5448:5592]

			clips, errs := processFile(dataPath, input.Output, input.Prefix, input.Filter, speciesName, callType, input.Certainty, imgSize, input.Color)

[2.5448]

[2.5592]

			clips, errs := processFile(dataPath, input.Output, input.Prefix, input.Filter, speciesName, callType, input.Certainty, imgSize, input.Color, input.WavOnly)

Replacement in tools/calls_clip.go at line 116 [9.2441]

B:BD[2.6206] → [2.6206:6352]

					clips, errs := processFile(dataPath, input.Output, input.Prefix, input.Filter, speciesName, callType, input.Certainty, imgSize, input.Color)

[2.6206]

[2.6352]

					clips, errs := processFile(dataPath, input.Output, input.Prefix, input.Filter, speciesName, callType, input.Certainty, imgSize, input.Color, input.WavOnly)

Replacement in tools/calls_clip.go at line 146 [9.2441]

B:BD[9.5658] → [8.2846:2989]

func processFile(dataPath, outputDir, prefix, filter, speciesName, callType string, certainty, imgSize int, color bool) ([]string, []string) {

[9.5658]

[9.5765]

func processFile(dataPath, outputDir, prefix, filter, speciesName, callType string, certainty, imgSize int, color, wavOnly bool) ([]string, []string) {

Replacement in tools/calls_clip.go at line 184 [9.2441]

B:BD[2.6950] → [2.6950:7078]

			clipFiles, err := generateClip(samples, sampleRate, outputDir, prefix, basename, seg.StartTime, seg.EndTime, imgSize, color)

[2.6950]

[2.7078]

			clipFiles, err := generateClip(samples, sampleRate, outputDir, prefix, basename, seg.StartTime, seg.EndTime, imgSize, color, wavOnly)

Replacement in tools/calls_clip.go at line 207 [9.2441]

B:BD[2.7640] → [2.7640:7770]

					clipFiles, err := generateClip(samples, sampleRate, outputDir, prefix, basename, seg.StartTime, seg.EndTime, imgSize, color)

[2.7640]

[2.7770]

					clipFiles, err := generateClip(samples, sampleRate, outputDir, prefix, basename, seg.StartTime, seg.EndTime, imgSize, color, wavOnly)

Replacement in tools/calls_clip.go at line 240 [9.2441]

B:BD[9.7681] → [10.739:901]

func generateClip(samples []float64, sampleRate int, outputDir, prefix, basename string, startTime, endTime float64, imgSize int, color bool) ([]string, error) {

[9.7681]

[9.7818]

func generateClip(samples []float64, sampleRate int, outputDir, prefix, basename string, startTime, endTime float64, imgSize int, color, wavOnly bool) ([]string, error) {

Deletion in tools/calls_clip.go at line 249 [9.2441]
B:BD[9.8056] → [9.8056:8110]
```
	pngPath := filepath.Join(outputDir, baseName+".png")
```

Replacement in tools/calls_clip.go at line 264 [9.2441]

B:BD[9.8883] → [10.902:927]

∅:D[10.927] → [9.9088:9125]

B:BD[9.9088] → [9.9088:9125]

B:BD[9.9240] → [9.9240:9299]

B:BD[9.9299] → [10.928:990]

∅:D[10.990] → [9.9363:9450]

B:BD[9.9363] → [9.9363:9450]

	// Generate spectrogram
	spectSampleRate := outputSampleRate
	config := utils.DefaultSpectrogramConfig(spectSampleRate)
	spectrogram := utils.GenerateSpectrogram(segSamples, config)
	if spectrogram == nil {
		return nil, fmt.Errorf("failed to generate spectrogram")
	}

[9.8883]

[9.9450]

	// Generate spectrogram and PNG unless --wav-only
	if !wavOnly {
		pngPath := filepath.Join(outputDir, baseName+".png")

Replacement in tools/calls_clip.go at line 268 [9.2441]

B:BD[9.9451] → [10.991:1213]

∅:D[10.1213] → [9.9499:9570]

B:BD[9.9499] → [9.9499:9570]

	// Create image (grayscale or color)
	var img image.Image
	if color {
		colorData := utils.ApplyL4Colormap(spectrogram)
		img = utils.CreateRGBImage(colorData)
	} else {
		img = utils.CreateGrayscaleImage(spectrogram)
	}
	if img == nil {
		return nil, fmt.Errorf("failed to create image")
	}

[9.9451]

[9.9570]

		spectSampleRate := outputSampleRate
		config := utils.DefaultSpectrogramConfig(spectSampleRate)
		spectrogram := utils.GenerateSpectrogram(segSamples, config)
		if spectrogram == nil {
			return nil, fmt.Errorf("failed to generate spectrogram")
		}

Replacement in tools/calls_clip.go at line 275 [9.2441]

B:BD[9.9571] → [10.1214:1267]

	resized := utils.ResizeImage(img, imgSize, imgSize)

[9.9571]

[9.9616]

		// Create image (grayscale or color)
		var img image.Image
		if color {
			colorData := utils.ApplyL4Colormap(spectrogram)
			img = utils.CreateRGBImage(colorData)
		} else {
			img = utils.CreateGrayscaleImage(spectrogram)
		}
		if img == nil {
			return nil, fmt.Errorf("failed to create image")
		}
		resized := utils.ResizeImage(img, imgSize, imgSize)

Replacement in tools/calls_clip.go at line 289 [9.2441]

B:BD[9.9617] → [2.8261:8420]

∅:D[2.8420] → [9.9667:9684]

B:BD[9.9667] → [9.9667:9684]

B:BD[9.9684] → [2.8421:8506]

	// Write PNG (O_EXCL fails atomically if file exists, replacing os.Stat check)
	pngFile, err := os.OpenFile(pngPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0644)
	if err != nil {
		if os.IsExist(err) {
			return nil, fmt.Errorf("file already exists: %s", pngPath)

[9.9617]

[2.8506]

		// Write PNG (O_EXCL fails atomically if file exists)
		pngFile, err := os.OpenFile(pngPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0644)
		if err != nil {
			if os.IsExist(err) {
				return nil, fmt.Errorf("file already exists: %s", pngPath)
			}
			return nil, fmt.Errorf("failed to create PNG: %w", err)
		}
		if err := utils.WritePNG(resized, pngFile); err != nil {
			pngFile.Close()
			return nil, fmt.Errorf("failed to write PNG: %w", err)

Deletion in tools/calls_clip.go at line 301 [9.2441]

∅:D[2.8510] → [9.9684:9803]

B:BD[9.9684] → [9.9684:9803]

		return nil, fmt.Errorf("failed to create PNG: %w", err)
	}
	if err := utils.WritePNG(resized, pngFile); err != nil {

Replacement in tools/calls_clip.go at line 302 [9.2441]
B:BD[9.9821] → [9.9821:9878]
```
		return nil, fmt.Errorf("failed to write PNG: %w", err)
```
[9.9821]
[9.9878]
```
		files = append(files, pngPath)
```
Deletion in tools/calls_clip.go at line 304 [9.2441]
B:BD[9.9881] → [9.9881:9930]
```
	pngFile.Close()
	files = append(files, pngPath)
```

Insertion in cmd/calls_clip.go at line 26 [9.10182]

[10.1552]

[9.11088]

	fmt.Fprintf(os.Stderr, "  --wav-only         Generate only WAV clips, skip spectrogram PNG generation\n")

Replacement in cmd/calls_clip.go at line 45 [9.10182]
∅:D[8.6487] → [10.1853:1869]
B:BD[10.1853] → [10.1853:1869]
```
	var color bool
```
[8.6487]
[8.6488]
```
	var color, wavOnly bool
```
Insertion in cmd/calls_clip.go at line 144 [9.10182]
[10.2194]
[10.2194]
```
			i++
		case "--wav-only":
			wavOnly = true
```
Insertion in cmd/calls_clip.go at line 193 [9.10182]
[8.7166]
[9.14302]
```
		WavOnly:   wavOnly,
```