ebur128_test.go

package ebur128

import (
	"math"
	"os"
	"path/filepath"
	"testing"
)

const testdataDir = "testdata"

func skipIfMissing(t *testing.T, path string) {
	t.Helper()
	if _, err := os.Stat(path); os.IsNotExist(err) {
		t.Skipf("run testdata/generate.sh to generate test files (missing %s)", filepath.Base(path))
	}
}

func loadAndMeasure(t *testing.T, file string) Result {
	t.Helper()
	path := filepath.Join(testdataDir, file)
	skipIfMissing(t, path)

	wav, err := readWAV(path)
	if err != nil {
		t.Fatalf("reading %s: %v", file, err)
	}
	if wav.sampleRate != sampleRate48k {
		t.Fatalf("%s: expected %d Hz, got %d Hz", file, sampleRate48k, wav.sampleRate)
	}

	meter, err := New(LayoutStereo, sampleRate48k)
	if err != nil {
		t.Fatal(err)
	}
	meter.Write(wav.samples)
	return meter.Loudness()
}

// ffmpeg reference: loud=-20.0, quiet=-40.0, lra=-20.1, gated=-20.1 LUFS

func TestIntegrated(t *testing.T) {
	tests := []struct {
		name     string
		file     string
		expected float64
		tol      float64
	}{
		{"loud-sine", "sine_stereo_1k_loud.wav", -20.0, 0.2},
		{"quiet-sine", "sine_stereo_1k_quiet.wav", -40.0, 0.2},
		{"lra-mix", "lra_stereo.wav", -20.1, 0.2},
		{"gated", "gated_stereo.wav", -20.1, 0.2},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := loadAndMeasure(t, tt.file)
			if math.Abs(result.IntegratedLoudness-tt.expected) > tt.tol {
				t.Errorf("integrated loudness = %.2f LUFS, expected %.1f ±%.1f",
					result.IntegratedLoudness, tt.expected, tt.tol)
			}
		})
	}
}

func TestLRA(t *testing.T) {
	tests := []struct {
		name     string
		file     string
		expected float64
		tol      float64
	}{
		{"constant-loud", "sine_stereo_1k_loud.wav", 0.0, 1.0},
		{"constant-quiet", "sine_stereo_1k_quiet.wav", 0.0, 1.0},
		{"loud-quiet-mix", "lra_stereo.wav", 20.0, 1.0},
		{"silence-then-loud", "gated_stereo.wav", 7.8, 2.0},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := loadAndMeasure(t, tt.file)
			if math.Abs(result.LoudnessRange-tt.expected) > tt.tol {
				t.Errorf("LRA = %.2f LU, expected %.1f ±%.1f",
					result.LoudnessRange, tt.expected, tt.tol)
			}
		})
	}
}

func TestTruePeak(t *testing.T) {
	tests := []struct {
		name     string
		file     string
		expected float64
		tol      float64
	}{
		{"loud-sine", "sine_stereo_1k_loud.wav", -20.0, 0.5},
		{"quiet-sine", "sine_stereo_1k_quiet.wav", -40.0, 0.5},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := loadAndMeasure(t, tt.file)
			if math.Abs(result.TruePeak-tt.expected) > tt.tol {
				t.Errorf("true peak = %.2f dBTP, expected %.1f ±%.1f",
					result.TruePeak, tt.expected, tt.tol)
			}
		})
	}
}

func TestGating(t *testing.T) {
	result := loadAndMeasure(t, "gated_stereo.wav")

	// 5s silence + 5s sine: silence should be gated out
	if result.IntegratedLoudness < -21.0 || result.IntegratedLoudness > -19.0 {
		t.Errorf("integrated loudness = %.2f LUFS, expected ~-20",
			result.IntegratedLoudness)
	}

	if result.GatedBlockCount == 0 {
		t.Error("expected non-zero gated block count")
	}
}

func TestNewUnsupportedSampleRate(t *testing.T) {
	_, err := New(LayoutStereo, 44100)
	if err == nil {
		t.Fatal("expected error for unsupported sample rate")
	}
}

func TestNewUnsupportedLayout(t *testing.T) {
	_, err := New(ChannelLayout(99), sampleRate48k)
	if err == nil {
		t.Fatal("expected error for unsupported channel layout")
	}
}

func TestWriteFloat32(t *testing.T) {
	const n = 48000
	f64 := make([]float64, n*2)
	f32 := make([]float32, n*2)
	for i := range n {
		s := math.Sin(2 * math.Pi * 1000 * float64(i) / sampleRate48k)
		f64[i*2] = s
		f64[i*2+1] = s
		f32[i*2] = float32(s)
		f32[i*2+1] = float32(s)
	}

	ref, _ := New(LayoutStereo, sampleRate48k)
	ref.Write(f64)
	got1 := ref.Loudness()

	meter, _ := New(LayoutStereo, sampleRate48k)
	meter.WriteFloat32(f32)
	got2 := meter.Loudness()

	if math.Abs(got1.IntegratedLoudness-got2.IntegratedLoudness) > 0.5 {
		t.Errorf("WriteFloat32 loudness %.2f differs from Write %.2f by more than 0.5 LUFS",
			got2.IntegratedLoudness, got1.IntegratedLoudness)
	}
}

func TestReset(t *testing.T) {
	meter, _ := New(LayoutStereo, sampleRate48k)

	buf := make([]float64, 48000*2)
	for i := range 48000 {
		s := math.Sin(2 * math.Pi * 1000 * float64(i) / sampleRate48k)
		buf[i*2] = s
		buf[i*2+1] = s
	}
	meter.Write(buf)
	got := meter.Loudness()
	if got.IntegratedLoudness < -50 {
		t.Fatalf("expected measurable loudness, got %.2f", got.IntegratedLoudness)
	}

	meter.Reset()
	got = meter.Loudness()
	if got.IntegratedLoudness != loudnessUnmeasurable {
		t.Errorf("after Reset, expected %.0f LUFS, got %.2f", loudnessUnmeasurable, got.IntegratedLoudness)
	}
}

func TestFinalize(t *testing.T) {
	meter, _ := New(LayoutStereo, sampleRate48k)

	// 4.5 sub-blocks: without Finalize = 1 gating block, with = 2
	n := 4800*4 + 2400
	buf := make([]float64, n*2)
	for i := range n {
		s := math.Sin(2 * math.Pi * 1000 * float64(i) / sampleRate48k)
		buf[i*2] = s
		buf[i*2+1] = s
	}

	meter.Write(buf)
	got := meter.Loudness()

	meter.Reset()
	meter.Write(buf)
	meter.Finalize()
	gotFin := meter.Loudness()

	if got.GatedBlockCount != 1 {
		t.Errorf("without Finalize: expected 1 gated block, got %d", got.GatedBlockCount)
	}
	if gotFin.GatedBlockCount != 2 {
		t.Errorf("with Finalize: expected 2 gated blocks, got %d", gotFin.GatedBlockCount)
	}
}