Publish the reproducible Sound Lab and FPGA Colour Lab sources
This commit is contained in:
commit
88254d7e24
27 files changed
+4574
No files matched your search
@@ -0,0 +1,169 @@
|
||||
# SPDX-License-Identifier: GPL-3.0-or-later
|
||||
"""Authored PCM fixtures; no ROMs, hardware, dependencies or listening claims."""
|
||||
|
||||
import hashlib
|
||||
import importlib.util
|
||||
import json
|
||||
import math
|
||||
from pathlib import Path
|
||||
import struct
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
import wave
|
||||
|
||||
|
||||
SCRIPT = Path(__file__).resolve().parents[1] / "audio" / "analyze.py"
|
||||
SPEC = importlib.util.spec_from_file_location("sound_lab_audio", SCRIPT)
|
||||
audio = importlib.util.module_from_spec(SPEC)
|
||||
SPEC.loader.exec_module(audio)
|
||||
|
||||
|
||||
class AudioTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temporary = tempfile.TemporaryDirectory(prefix="soundlab-audio-")
|
||||
self.addCleanup(self.temporary.cleanup)
|
||||
self.directory = Path(self.temporary.name)
|
||||
|
||||
def wav(self, channels, rate=48000, width=2):
|
||||
path = self.directory / "capture.wav"
|
||||
payload = bytearray()
|
||||
for frame in zip(*channels):
|
||||
for value in frame:
|
||||
payload.extend((value + 128 if width == 1 else value).to_bytes(width, "little", signed=width != 1))
|
||||
with wave.open(str(path), "wb") as output:
|
||||
output.setnchannels(len(channels))
|
||||
output.setsampwidth(width)
|
||||
output.setframerate(rate)
|
||||
output.writeframes(payload)
|
||||
return path
|
||||
|
||||
def manifest(self, duration=1, **kwargs):
|
||||
segment = dict(case_id="AUTHORED", kind="tone", start_seconds=0, end_seconds=duration)
|
||||
segment.update(kwargs)
|
||||
path = self.directory / "intervals.json"
|
||||
path.write_text(json.dumps({"segments": [segment]}))
|
||||
return path
|
||||
|
||||
def sine(self, rate, hz, amplitude=16384):
|
||||
return [round(amplitude * math.sin(2 * math.pi * hz * index / rate)) for index in range(rate)]
|
||||
|
||||
def test_tone_both_sample_rates_and_input_hashes(self):
|
||||
for rate in (44100, 48000):
|
||||
with self.subTest(rate=rate):
|
||||
wav = self.wav([self.sine(rate, 440)], rate)
|
||||
manifest = self.manifest(nominal_hz=440)
|
||||
original = wav.read_bytes()
|
||||
report = audio.analyze(wav, manifest)
|
||||
channel = report["segments"][0]["channels"][0]
|
||||
self.assertEqual(report["capture"]["sample_rate_hz"], rate)
|
||||
self.assertAlmostEqual(channel["frequency"]["estimated_hz"], 440, delta=0.02)
|
||||
self.assertAlmostEqual(channel["rms_full_scale"], 0.5 / math.sqrt(2), delta=0.0001)
|
||||
self.assertEqual(report["capture"]["sha256"], hashlib.sha256(original).hexdigest())
|
||||
self.assertEqual(wav.read_bytes(), original)
|
||||
self.assertEqual(report["human_status"], "NOT_OBSERVED")
|
||||
self.assertEqual(channel["assessment"], "MEASURE_BASELINE")
|
||||
|
||||
def test_silence_and_rails(self):
|
||||
wav = self.wav([[0] * 48000])
|
||||
report = audio.analyze(wav, self.manifest(kind="silence"))
|
||||
channel = report["segments"][0]["channels"][0]
|
||||
self.assertEqual(channel["rms_full_scale"], 0)
|
||||
self.assertEqual(channel["near_zero_ratio"], 1)
|
||||
self.assertNotIn("frequency", channel)
|
||||
wav = self.wav([[-32768, 32767, 0, 1]])
|
||||
channel = audio.analyze(wav, self.manifest(duration=4 / 48000, kind="noise"))["segments"][0]["channels"][0]
|
||||
self.assertEqual(channel["clipping_count"], 2)
|
||||
self.assertEqual(channel["peak_full_scale"], 1)
|
||||
self.assertEqual(channel["near_zero_ratio"], 0.5)
|
||||
|
||||
def test_stereo_keeps_different_channels(self):
|
||||
wav = self.wav([self.sine(48000, 440), self.sine(48000, 880, 8192)])
|
||||
channels = audio.analyze(wav, self.manifest())["segments"][0]["channels"]
|
||||
self.assertAlmostEqual(channels[0]["frequency"]["estimated_hz"], 440, delta=0.02)
|
||||
self.assertAlmostEqual(channels[1]["frequency"]["estimated_hz"], 880, delta=0.02)
|
||||
self.assertAlmostEqual(channels[0]["rms_full_scale"] / channels[1]["rms_full_scale"], 2, delta=0.001)
|
||||
|
||||
def test_supported_integer_widths(self):
|
||||
for width in (1, 2, 3, 4):
|
||||
with self.subTest(width=width):
|
||||
wav = self.wav([[0, 1, -1, 2]], width=width)
|
||||
report = audio.analyze(wav, self.manifest(duration=4 / 48000, kind="silence"))
|
||||
self.assertEqual(report["capture"]["bit_depth"], width * 8)
|
||||
self.assertEqual(report["segments"][0]["channels"][0]["near_zero_ratio"], 0.75)
|
||||
|
||||
def test_interval_validation_and_rounding(self):
|
||||
wav = self.wav([[0] * 48000])
|
||||
for kwargs in ({"start_seconds": -1}, {"end_seconds": 2}, {"end_seconds": 0},
|
||||
{"start_seconds": 0.5, "end_seconds": 0.4}, {"start_seconds": float("nan")},
|
||||
{"kind": "unknown"}, {"end_seconds": True}, {"case_id": ""},
|
||||
{"start_seconds": 0.000001, "end_seconds": 0.000002}):
|
||||
with self.subTest(kwargs=kwargs):
|
||||
with self.assertRaises(ValueError):
|
||||
audio.analyze(wav, self.manifest(**kwargs))
|
||||
report = audio.analyze(wav, self.manifest(start_seconds=0.00001, end_seconds=0.00005))
|
||||
self.assertEqual(report["segments"][0]["start_frame"], 1)
|
||||
self.assertEqual(report["segments"][0]["stop_frame"], 3)
|
||||
self.assertEqual(report["segments"][0]["byte_offset_in_pcm_payload"], 2)
|
||||
|
||||
def test_compression_float_width_and_truncation_rejected(self):
|
||||
wav = self.wav([[0] * 48])
|
||||
original = wav.read_bytes()
|
||||
for format_tag, bits, block_align in ((6, 16, 2), (3, 32, 4), (1, 40, 5)):
|
||||
with self.subTest(format_tag=format_tag, bits=bits):
|
||||
damaged = bytearray(original)
|
||||
struct.pack_into("<H", damaged, 20, format_tag)
|
||||
struct.pack_into("<H", damaged, 34, bits)
|
||||
struct.pack_into("<H", damaged, 32, block_align)
|
||||
wav.write_bytes(damaged)
|
||||
with self.assertRaises(ValueError):
|
||||
audio.load_pcm(wav)
|
||||
wav.write_bytes(original[:-5])
|
||||
with self.assertRaises(ValueError):
|
||||
audio.load_pcm(wav)
|
||||
|
||||
def test_explicit_tolerance_and_no_inferred_listening(self):
|
||||
wav = self.wav([self.sine(48000, 440)])
|
||||
tolerance = {"absolute_hz": 1, "qualification": "Authored digital fixture; known sample rate"}
|
||||
report = audio.analyze(wav, self.manifest(nominal_hz=440, frequency_tolerance=tolerance))
|
||||
self.assertEqual(report["segments"][0]["channels"][0]["assessment"], "WITHIN_QUALIFIED_TOLERANCE")
|
||||
report = audio.analyze(wav, self.manifest(nominal_hz=450, frequency_tolerance=tolerance))
|
||||
self.assertEqual(report["segments"][0]["channels"][0]["assessment"], "OUTSIDE_QUALIFIED_TOLERANCE")
|
||||
self.assertEqual(report["assessment"], "MEASURE_BASELINE")
|
||||
with self.assertRaises(ValueError):
|
||||
audio.analyze(wav, self.manifest(nominal_hz=440, frequency_tolerance={"absolute_hz": 1}))
|
||||
wav = self.wav([[0] * 48000])
|
||||
channel = audio.analyze(wav, self.manifest())["segments"][0]["channels"][0]
|
||||
self.assertIsNone(channel["frequency"]["estimated_hz"])
|
||||
|
||||
def test_repeated_comparison_requires_both_identities(self):
|
||||
wav = self.wav([self.sine(48000, 440)])
|
||||
manifest = self.manifest(vector_id="VECTOR-A")
|
||||
first = json.loads(manifest.read_text())["segments"][0]
|
||||
cases = [first, dict(first), dict(first, vector_id="VECTOR-B"),
|
||||
dict(first, case_id="OTHER"), {k: v for k, v in first.items() if k != "vector_id"}]
|
||||
manifest.write_text(json.dumps(cases))
|
||||
comparisons = audio.analyze(wav, manifest)["repeated_cases"]
|
||||
self.assertEqual(len(comparisons), 1)
|
||||
self.assertEqual(comparisons[0]["observed_segment_index"], 1)
|
||||
self.assertEqual(comparisons[0]["assessment"], "OBSERVED")
|
||||
|
||||
def test_cli_protects_existing_reports_and_inputs(self):
|
||||
wav = self.wav([[0] * 48])
|
||||
manifest = self.manifest(duration=0.001)
|
||||
output = self.directory / "report.json"
|
||||
command = [sys.executable, str(SCRIPT), str(wav), str(manifest), "--output", str(output)]
|
||||
result = subprocess.run(command, capture_output=True)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
original_report = output.read_bytes()
|
||||
self.assertEqual(subprocess.run(command, capture_output=True).returncode, 2)
|
||||
self.assertEqual(output.read_bytes(), original_report)
|
||||
self.assertEqual(subprocess.run(command + ["--overwrite"], capture_output=True).returncode, 0)
|
||||
original = wav.read_bytes()
|
||||
self.assertEqual(subprocess.run(command[:-1] + [str(wav), "--overwrite"], capture_output=True).returncode, 2)
|
||||
self.assertEqual(wav.read_bytes(), original)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user