Initial Commit

packages/media/audio/audio-analysis-pitch/src/algorithms/chord-matching.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, it } from "@suaveplan/testing/runner";
+import {
+    type FrameChord,
+    matchChord,
+    mergeRuns,
+    smoothLabels,
+} from "./chord-matching.js";
+
+function chromaFor(pcs: number[]): Float32Array {
+    const v = new Float32Array(12);
+    for (const pc of pcs) v[pc] = 1;
+    return v;
+}
+
+describe("matchChord", () => {
+    it("matches a C major triad to C major", { timeout: 5000 }, () => {
+        const r = matchChord(chromaFor([0, 4, 7]));
+        expect(r.root).toBe("C");
+        expect(r.quality).toBe("major");
+        expect(r.confidence).toBeGreaterThan(0);
+    });
+
+    it("matches an A minor triad to A minor", { timeout: 5000 }, () => {
+        const r = matchChord(chromaFor([9, 0, 4]));
+        expect(r.root).toBe("A");
+        expect(r.quality).toBe("minor");
+    });
+
+    it("matches a diminished triad", { timeout: 5000 }, () => {
+        const r = matchChord(chromaFor([0, 3, 6]));
+        expect(r.quality).toBe("dim");
+    });
+
+    it("matches an augmented triad", { timeout: 5000 }, () => {
+        const r = matchChord(chromaFor([0, 4, 8]));
+        expect(r.quality).toBe("aug");
+    });
+
+    it("zero chroma returns the default with zero confidence", {
+        timeout: 5000,
+    }, () => {
+        const r = matchChord(new Float32Array(12));
+        expect(r.confidence).toBe(0);
+    });
+});
+
+describe("smoothLabels", () => {
+    it("collapses a single odd label between two identical neighbours", {
+        timeout: 5000,
+    }, () => {
+        const c: FrameChord[] = [
+            { root: "C", quality: "major", confidence: 0.9 },
+            { root: "G", quality: "major", confidence: 0.4 },
+            { root: "C", quality: "major", confidence: 0.9 },
+        ];
+        const s = smoothLabels(c);
+        expect(s[1]?.root).toBe("C");
+    });
+
+    it("leaves stable runs unchanged", { timeout: 5000 }, () => {
+        const c: FrameChord[] = [
+            { root: "C", quality: "major", confidence: 0.9 },
+            { root: "C", quality: "major", confidence: 0.9 },
+        ];
+        expect(smoothLabels(c)).toEqual(c);
+    });
+});
+
+describe("mergeRuns", () => {
+    it("merges adjacent identical labels into single chord records", {
+        timeout: 5000,
+    }, () => {
+        const labels: FrameChord[] = [
+            { root: "C", quality: "major", confidence: 0.9 },
+            { root: "C", quality: "major", confidence: 0.95 },
+            { root: "G", quality: "major", confidence: 0.8 },
+            { root: "G", quality: "major", confidence: 0.85 },
+        ];
+        const merged = mergeRuns(labels, { hopSeconds: 0.1, minDuration: 0 });
+        expect(merged.length).toBe(2);
+        expect(merged[0]?.root).toBe("C");
+        expect(merged[1]?.root).toBe("G");
+        expect(merged[0]?.timestamp).toBeLessThan(merged[1]?.timestamp ?? 0);
+    });
+
+    it("drops runs shorter than minDuration", { timeout: 5000 }, () => {
+        const labels: FrameChord[] = [
+            { root: "C", quality: "major", confidence: 0.9 },
+            { root: "G", quality: "major", confidence: 0.4 },
+            { root: "G", quality: "major", confidence: 0.4 },
+            { root: "C", quality: "major", confidence: 0.9 },
+        ];
+        // Smoothing keeps middle G run (length 2), C bookends not — but
+        // minDuration=0.3 with hopSeconds=0.1 drops the single-frame C bookends.
+        const merged = mergeRuns(labels, { hopSeconds: 0.1, minDuration: 0.3 });
+        // Each pure run is too short — all dropped or none survive.
+        expect(merged.every((c) => c.duration >= 0.3)).toBe(true);
+    });
+
+    it("returns empty array for empty labels", { timeout: 5000 }, () => {
+        expect(mergeRuns([], { hopSeconds: 0.1, minDuration: 0 })).toEqual([]);
+    });
+
+    it("emits a time-ordered smoothed chord progression", {
+        timeout: 5000,
+    }, () => {
+        const labels: FrameChord[] = [
+            { root: "C", quality: "major", confidence: 0.9 },
+            { root: "C", quality: "major", confidence: 0.9 },
+            { root: "C", quality: "major", confidence: 0.9 },
+            { root: "G", quality: "major", confidence: 0.9 },
+            { root: "G", quality: "major", confidence: 0.9 },
+            { root: "G", quality: "major", confidence: 0.9 },
+        ];
+        const merged = mergeRuns(labels, { hopSeconds: 0.1, minDuration: 0 });
+        expect(merged.map((c) => c.root)).toEqual(["C", "G"]);
+        for (let i = 1; i < merged.length; i++) {
+            const prev = merged[i - 1];
+            const cur = merged[i];
+            expect((cur?.timestamp ?? 0) > (prev?.timestamp ?? 0)).toBe(true);
+        }
+    });
+
+    it("coalesces non-adjacent identical labels merged by smoothing", {
+        timeout: 5000,
+    }, () => {
+        const labels: FrameChord[] = [
+            { root: "C", quality: "major", confidence: 0.5 },
+            { root: "C", quality: "major", confidence: 0.5 },
+            { root: "G", quality: "major", confidence: 0.4 },
+            { root: "C", quality: "major", confidence: 0.5 },
+            { root: "C", quality: "major", confidence: 0.5 },
+        ];
+        const merged = mergeRuns(labels, { hopSeconds: 0.1, minDuration: 0 });
+        // smoothing converts the lone G to a C — should coalesce to a single C run.
+        expect(merged.length).toBe(1);
+        expect(merged[0]?.root).toBe("C");
+    });
+});