audio is prepared, next is MXL part

2026-09-16 22:44:27 +03:00
parent ce547451a0
commit 70c966dbad
5 changed files with 333 additions and 5 deletions
@@ -0,0 +1,155 @@
+package audio
+
+import (
+	"bytes"
+	"encoding/binary"
+	"math"
+	"testing"
+
+	"mxl-pattern-generator/internal/flowdef"
+)
+
+const testAudioID = "b3bb5be7-9fe9-4324-a5bb-4c70e1084449"
+
+func testConfig(t *testing.T, channels uint, rate flowdef.Rational, level float64) Config {
+	t.Helper()
+	definition, err := flowdef.NewFloat32Audio(testAudioID, channels, rate)
+	if err != nil {
+		t.Fatalf("NewFloat32Audio: %v", err)
+	}
+	return Config{Definition: definition, LevelDBFS: level}
+}
+
+func decodeSample(data []byte, index int) float32 {
+	return math.Float32frombits(binary.LittleEndian.Uint32(data[index*4:]))
+}
+
+func requireSampleNear(t *testing.T, got, want float32) {
+	t.Helper()
+	if math.Abs(float64(got-want)) > 1e-6 {
+		t.Fatalf("sample = %.8f, want %.8f", got, want)
+	}
+}
+
+func TestNewSineGeneratorValidation(t *testing.T) {
+	valid := testConfig(t, 2, flowdef.Rational{Numerator: 48000, Denominator: 1}, LevelEBUDBFS)
+
+	tests := []struct {
+		name    string
+		cfg     Config
+		baseHz  float64
+		wantErr bool
+	}{
+		{name: "valid", cfg: valid, baseHz: 1000},
+		{name: "zero channels", cfg: Config{Definition: flowdef.Audio{SampleRate: flowdef.Rational{Numerator: 48000, Denominator: 1}}, LevelDBFS: LevelEBUDBFS}, baseHz: 1000, wantErr: true},
+		{name: "zero numerator", cfg: Config{Definition: flowdef.Audio{SampleRate: flowdef.Rational{Denominator: 1}, ChannelCount: 1}, LevelDBFS: LevelEBUDBFS}, baseHz: 1000, wantErr: true},
+		{name: "zero denominator", cfg: Config{Definition: flowdef.Audio{SampleRate: flowdef.Rational{Numerator: 48000}, ChannelCount: 1}, LevelDBFS: LevelEBUDBFS}, baseHz: 1000, wantErr: true},
+		{name: "zero base", cfg: valid, baseHz: 0, wantErr: true},
+		{name: "NaN base", cfg: valid, baseHz: math.NaN(), wantErr: true},
+		{name: "NaN level", cfg: Config{Definition: valid.Definition, LevelDBFS: math.NaN()}, baseHz: 1000, wantErr: true},
+		{name: "above full scale", cfg: Config{Definition: valid.Definition, LevelDBFS: 1}, baseHz: 1000, wantErr: true},
+		{name: "too quiet", cfg: Config{Definition: valid.Definition, LevelDBFS: -101}, baseHz: 1000, wantErr: true},
+		{name: "Nyquist", cfg: testConfig(t, 24, flowdef.Rational{Numerator: 48000, Denominator: 1}, LevelEBUDBFS), baseHz: 1000, wantErr: true},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			_, err := NewSineGenerator(tc.cfg, tc.baseHz)
+			if (err != nil) != tc.wantErr {
+				t.Fatalf("error = %v, wantErr %v", err, tc.wantErr)
+			}
+		})
+	}
+}
+
+func TestNewSineGeneratorPreservesRationalSampleRate(t *testing.T) {
+	cfg := testConfig(t, 1, flowdef.Rational{Numerator: 48000, Denominator: 1001}, LevelEBUDBFS)
+	gen, err := NewSineGenerator(cfg, 1)
+	if err != nil {
+		t.Fatalf("NewSineGenerator: %v", err)
+	}
+	want := 48000.0 / 1001.0
+	if math.Abs(gen.sampleRate-want) > 1e-12 {
+		t.Fatalf("sample rate = %.12f, want %.12f", gen.sampleRate, want)
+	}
+}
+
+func TestSineGeneratorKnownSamplesAndChannels(t *testing.T) {
+	cfg := testConfig(t, 2, flowdef.Rational{Numerator: 48000, Denominator: 1}, LevelSMPTEDBFS)
+	gen, err := NewSineGenerator(cfg, 1000)
+	if err != nil {
+		t.Fatalf("NewSineGenerator: %v", err)
+	}
+
+	channel0 := make([]byte, 37*4)
+	if err := gen.Generate(0, 0, channel0); err != nil {
+		t.Fatalf("Generate channel 0: %v", err)
+	}
+	requireSampleNear(t, decodeSample(channel0, 0), 0)
+	requireSampleNear(t, decodeSample(channel0, 12), 0.1)
+	requireSampleNear(t, decodeSample(channel0, 24), 0)
+	requireSampleNear(t, decodeSample(channel0, 36), -0.1)
+
+	channel1 := make([]byte, 7*4)
+	if err := gen.Generate(1, 0, channel1); err != nil {
+		t.Fatalf("Generate channel 1: %v", err)
+	}
+	requireSampleNear(t, decodeSample(channel1, 6), 0.1)
+}
+
+func TestSineGeneratorUsesConfiguredBaseFrequency(t *testing.T) {
+	cfg := testConfig(t, 1, flowdef.Rational{Numerator: 48000, Denominator: 1}, LevelEBUDBFS)
+	gen, err := NewSineGenerator(cfg, 2000)
+	if err != nil {
+		t.Fatalf("NewSineGenerator: %v", err)
+	}
+
+	data := make([]byte, 7*4)
+	if err := gen.Generate(0, 0, data); err != nil {
+		t.Fatalf("Generate: %v", err)
+	}
+	wantPeak := float32(math.Pow(10, LevelEBUDBFS/20))
+	requireSampleNear(t, decodeSample(data, 6), wantPeak)
+}
+
+func TestSineGeneratorFragmentContinuity(t *testing.T) {
+	cfg := testConfig(t, 1, flowdef.Rational{Numerator: 48000, Denominator: 1}, LevelEBUDBFS)
+	gen, err := NewSineGenerator(cfg, 1000)
+	if err != nil {
+		t.Fatalf("NewSineGenerator: %v", err)
+	}
+
+	whole := make([]byte, 40*4)
+	if err := gen.Generate(0, 100, whole); err != nil {
+		t.Fatalf("Generate whole: %v", err)
+	}
+	first := make([]byte, 13*4)
+	second := make([]byte, 27*4)
+	if err := gen.Generate(0, 100, first, second); err != nil {
+		t.Fatalf("Generate fragments: %v", err)
+	}
+	joined := append(append([]byte(nil), first...), second...)
+	if !bytes.Equal(joined, whole) {
+		t.Fatal("fragmented output differs from contiguous output")
+	}
+}
+
+func TestSineGeneratorRejectsInvalidInputWithoutWriting(t *testing.T) {
+	cfg := testConfig(t, 1, flowdef.Rational{Numerator: 48000, Denominator: 1}, LevelEBUDBFS)
+	gen, err := NewSineGenerator(cfg, 1000)
+	if err != nil {
+		t.Fatalf("NewSineGenerator: %v", err)
+	}
+
+	first := bytes.Repeat([]byte{0xAA}, 8)
+	before := append([]byte(nil), first...)
+	if err := gen.Generate(0, 0, first, make([]byte, 3)); err == nil {
+		t.Fatal("Generate accepted a misaligned fragment")
+	}
+	if !bytes.Equal(first, before) {
+		t.Fatal("Generate modified data before reporting an invalid fragment")
+	}
+	if err := gen.Generate(1, 0, make([]byte, 4)); err == nil {
+		t.Fatal("Generate accepted an out-of-range channel")
+	}
+}