170 lines
8.6 KiB
Python
170 lines
8.6 KiB
Python
# 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()
|