Level_1: File restructure to support centralized development
This commit is contained in:
@@ -0,0 +1,234 @@
|
||||
# ------------------------------------------------------------
|
||||
# AAC Coder/Decoder - Sequence Segmentation Control Tests
|
||||
#
|
||||
# Multimedia course at Aristotle University of
|
||||
# Thessaloniki (AUTh)
|
||||
#
|
||||
# Author:
|
||||
# Christos Choutouridis (ΑΕΜ 8997)
|
||||
# cchoutou@ece.auth.gr
|
||||
#
|
||||
# Description:
|
||||
# Tests for Sequence Segmentation Control module (SSC).
|
||||
# ------------------------------------------------------------
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import numpy as np
|
||||
|
||||
from core.aac_ssc import aac_SSC
|
||||
from core.aac_types import FrameT
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
# Helper fixtures for SSC
|
||||
# -----------------------------------------------------------------------------
|
||||
|
||||
def _next_frame_no_attack() -> FrameT:
|
||||
"""
|
||||
Build a next_frame_T that must NOT trigger ESH detection.
|
||||
|
||||
Uses exact zeros so all segment energies are zero and the condition
|
||||
s[l] > 1e-3 cannot hold for any l.
|
||||
"""
|
||||
return np.zeros((2048, 2), dtype=np.float64)
|
||||
|
||||
|
||||
def _next_frame_strong_attack(
|
||||
*,
|
||||
attack_left: bool,
|
||||
attack_right: bool,
|
||||
segment_l: int = 4,
|
||||
baseline: float = 1e-6,
|
||||
burst_amp: float = 1.0,
|
||||
) -> FrameT:
|
||||
"""
|
||||
Build a next_frame_T (2048x2) that should trigger ESH detection on selected channels.
|
||||
|
||||
Attack criterion (spec):
|
||||
Attack exists if there exists l in {1..7} such that:
|
||||
s[l] > 1e-3 and ds[l] > 10,
|
||||
where s[l] is the energy of segment l (length 128) after high-pass filtering,
|
||||
and ds[l] = s[l] / s[l-1].
|
||||
|
||||
Construction:
|
||||
- A small baseline is added everywhere to avoid relying on the epsilon guard in ds,
|
||||
keeping ds behavior stable/reproducible.
|
||||
- A strong burst is added inside a chosen segment l in 1..7.
|
||||
"""
|
||||
if not (1 <= segment_l <= 7):
|
||||
raise ValueError(f"segment_l must be in [1, 7], got {segment_l}.")
|
||||
|
||||
x = np.full((2048, 2), baseline, dtype=np.float64)
|
||||
|
||||
a = segment_l * 128
|
||||
b = (segment_l + 1) * 128
|
||||
|
||||
if attack_left:
|
||||
x[a:b, 0] += burst_amp
|
||||
if attack_right:
|
||||
x[a:b, 1] += burst_amp
|
||||
|
||||
return x
|
||||
|
||||
|
||||
def _next_frame_below_s_threshold(
|
||||
*,
|
||||
left: bool,
|
||||
right: bool,
|
||||
segment_l: int = 4,
|
||||
impulse_amp: float = 0.01,
|
||||
) -> FrameT:
|
||||
"""
|
||||
Construct a next_frame_T where s[l] is below 1e-3, so ESH must NOT be triggered,
|
||||
even if the ratio ds[l] could be large.
|
||||
|
||||
We place a single impulse of amplitude 'impulse_amp' inside one segment.
|
||||
Approx. segment energy: s[l] ~= impulse_amp^2.
|
||||
|
||||
Example:
|
||||
impulse_amp = 0.01 => s[l] ~= 1e-4 < 1e-3
|
||||
"""
|
||||
if not (1 <= segment_l <= 7):
|
||||
raise ValueError(f"segment_l must be in [1, 7], got {segment_l}.")
|
||||
|
||||
x = np.zeros((2048, 2), dtype=np.float64)
|
||||
|
||||
idx = segment_l * 128 + 10 # inside segment l
|
||||
if left:
|
||||
x[idx, 0] = impulse_amp
|
||||
if right:
|
||||
x[idx, 1] = impulse_amp
|
||||
|
||||
return x
|
||||
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
# 1) Fixed/mandatory cases (prev frame type forces current type)
|
||||
# -----------------------------------------------------------------------------
|
||||
|
||||
def test_ssc_fixed_cases_prev_lss_and_lps() -> None:
|
||||
"""
|
||||
Spec:
|
||||
- If prev was LSS => current MUST be ESH
|
||||
- If prev was LPS => current MUST be OLS
|
||||
independent of attack detection on (i+1).
|
||||
"""
|
||||
frame_t: FrameT = np.zeros((2048, 2), dtype=np.float64)
|
||||
|
||||
next_attack = _next_frame_strong_attack(attack_left=True, attack_right=True)
|
||||
|
||||
out1 = aac_SSC(frame_t, next_attack, "LSS")
|
||||
assert out1 == "ESH"
|
||||
|
||||
out2 = aac_SSC(frame_t, next_attack, "LPS")
|
||||
assert out2 == "OLS"
|
||||
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
# 2) Cases requiring next-frame ESH prediction (attack computation)
|
||||
# -----------------------------------------------------------------------------
|
||||
|
||||
def test_prev_ols_next_not_esh_returns_ols() -> None:
|
||||
"""
|
||||
If prev=OLS, current is:
|
||||
- LSS iff (i+1) is predicted ESH
|
||||
- else OLS
|
||||
Here: no attack => expect OLS.
|
||||
"""
|
||||
frame_t: FrameT = np.zeros((2048, 2), dtype=np.float64)
|
||||
next_t = _next_frame_no_attack()
|
||||
|
||||
out = aac_SSC(frame_t, next_t, "OLS")
|
||||
assert out == "OLS"
|
||||
|
||||
|
||||
def test_prev_ols_next_esh_both_channels_returns_lss() -> None:
|
||||
"""
|
||||
prev=OLS and next predicted ESH for both channels:
|
||||
per-channel: LSS, LSS
|
||||
merged: LSS
|
||||
"""
|
||||
frame_t: FrameT = np.zeros((2048, 2), dtype=np.float64)
|
||||
next_t = _next_frame_strong_attack(attack_left=True, attack_right=True)
|
||||
|
||||
out = aac_SSC(frame_t, next_t, "OLS")
|
||||
assert out == "LSS"
|
||||
|
||||
|
||||
def test_prev_ols_next_esh_one_channel_returns_lss() -> None:
|
||||
"""
|
||||
prev=OLS:
|
||||
- one channel predicts ESH => LSS
|
||||
- other channel predicts not ESH => OLS
|
||||
Merge table: OLS + LSS => LSS (either side).
|
||||
"""
|
||||
frame_t: FrameT = np.zeros((2048, 2), dtype=np.float64)
|
||||
|
||||
next1_t = _next_frame_strong_attack(attack_left=True, attack_right=False)
|
||||
out1 = aac_SSC(frame_t, next1_t, "OLS")
|
||||
assert out1 == "LSS"
|
||||
|
||||
next2_t = _next_frame_strong_attack(attack_left=False, attack_right=True)
|
||||
out2 = aac_SSC(frame_t, next2_t, "OLS")
|
||||
assert out2 == "LSS"
|
||||
|
||||
|
||||
def test_prev_esh_next_esh_both_channels_returns_esh() -> None:
|
||||
"""
|
||||
prev=ESH and next predicted ESH for both channels:
|
||||
per-channel: ESH, ESH
|
||||
merged: ESH
|
||||
"""
|
||||
frame_t: FrameT = np.zeros((2048, 2), dtype=np.float64)
|
||||
next_t = _next_frame_strong_attack(attack_left=True, attack_right=True)
|
||||
|
||||
out = aac_SSC(frame_t, next_t, "ESH")
|
||||
assert out == "ESH"
|
||||
|
||||
|
||||
def test_prev_esh_next_not_esh_both_channels_returns_lps() -> None:
|
||||
"""
|
||||
prev=ESH and next not predicted ESH for both channels:
|
||||
per-channel: LPS, LPS
|
||||
merged: LPS
|
||||
"""
|
||||
frame_t: FrameT = np.zeros((2048, 2), dtype=np.float64)
|
||||
next_t = _next_frame_no_attack()
|
||||
|
||||
out = aac_SSC(frame_t, next_t, "ESH")
|
||||
assert out == "LPS"
|
||||
|
||||
|
||||
def test_prev_esh_next_esh_one_channel_merged_is_esh() -> None:
|
||||
"""
|
||||
prev=ESH:
|
||||
- one channel predicts ESH => ESH
|
||||
- other channel predicts not ESH => LPS
|
||||
Merge table: ESH + LPS => ESH (either side).
|
||||
"""
|
||||
frame_t: FrameT = np.zeros((2048, 2), dtype=np.float64)
|
||||
|
||||
next1_t = _next_frame_strong_attack(attack_left=True, attack_right=False)
|
||||
out1 = aac_SSC(frame_t, next1_t, "ESH")
|
||||
assert out1 == "ESH"
|
||||
|
||||
next2_t = _next_frame_strong_attack(attack_left=False, attack_right=True)
|
||||
out2 = aac_SSC(frame_t, next2_t, "ESH")
|
||||
assert out2 == "ESH"
|
||||
|
||||
|
||||
def test_threshold_s_must_exceed_1e_3() -> None:
|
||||
"""
|
||||
Spec: next frame is predicted ESH only if:
|
||||
s[l] > 1e-3 AND ds[l] > 10
|
||||
for some l in 1..7.
|
||||
|
||||
This test checks the necessity of the s[l] threshold:
|
||||
- Create a frame with s[l] ~= 1e-4 < 1e-3 (single impulse with amp 0.01).
|
||||
- Expect: not classified as ESH -> for prev=OLS return OLS.
|
||||
"""
|
||||
frame_t: FrameT = np.zeros((2048, 2), dtype=np.float64)
|
||||
next_t = _next_frame_below_s_threshold(left=True, right=True, impulse_amp=0.01)
|
||||
|
||||
out = aac_SSC(frame_t, next_t, "OLS")
|
||||
assert out == "OLS"
|
||||
@@ -0,0 +1,156 @@
|
||||
# ------------------------------------------------------------
|
||||
# AAC Coder/Decoder - AAC Coder/DecoderTests
|
||||
#
|
||||
# Multimedia course at Aristotle University of
|
||||
# Thessaloniki (AUTh)
|
||||
#
|
||||
# Author:
|
||||
# Christos Choutouridis (ΑΕΜ 8997)
|
||||
# cchoutou@ece.auth.gr
|
||||
#
|
||||
# Description:
|
||||
# Tests for AAC Coder/Decoder module.
|
||||
# ------------------------------------------------------------
|
||||
from __future__ import annotations
|
||||
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
import soundfile as sf
|
||||
|
||||
from core.aac_coder import aac_coder_1
|
||||
from core.aac_decoder import aac_decoder_1
|
||||
from core.aac_types import *
|
||||
|
||||
|
||||
# Helper "fixtures" for aac_coder_1 / i_aac_coder_1
|
||||
# -----------------------------------------------------------------------------
|
||||
|
||||
def _snr_db(x_ref: StereoSignal, x_hat: StereoSignal) -> float:
|
||||
"""
|
||||
Compute overall SNR (dB) over all samples and channels after aligning lengths.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x_ref : StereoSignal
|
||||
Reference signal, shape (N, 2) typical.
|
||||
x_hat : StereoSignal
|
||||
Reconstructed signal, shape (M, 2) typical.
|
||||
|
||||
Returns
|
||||
-------
|
||||
float
|
||||
SNR in dB.
|
||||
- Returns +inf if noise power is zero.
|
||||
- Returns -inf if signal power is zero.
|
||||
"""
|
||||
x_ref = np.asarray(x_ref, dtype=np.float64)
|
||||
x_hat = np.asarray(x_hat, dtype=np.float64)
|
||||
|
||||
# Be conservative: align lengths and common channels.
|
||||
if x_ref.ndim == 1:
|
||||
x_ref = x_ref.reshape(-1, 1)
|
||||
if x_hat.ndim == 1:
|
||||
x_hat = x_hat.reshape(-1, 1)
|
||||
|
||||
n = min(x_ref.shape[0], x_hat.shape[0])
|
||||
c = min(x_ref.shape[1], x_hat.shape[1])
|
||||
|
||||
x_ref = x_ref[:n, :c]
|
||||
x_hat = x_hat[:n, :c]
|
||||
|
||||
err = x_ref - x_hat
|
||||
ps = float(np.sum(x_ref * x_ref))
|
||||
pn = float(np.sum(err * err))
|
||||
|
||||
if pn <= 0.0:
|
||||
return float("inf")
|
||||
if ps <= 0.0:
|
||||
return float("-inf")
|
||||
|
||||
return float(10.0 * np.log10(ps / pn))
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def tmp_stereo_wav(tmp_path: Path) -> Path:
|
||||
"""
|
||||
Create a temporary 48 kHz stereo WAV with random samples.
|
||||
"""
|
||||
rng = np.random.default_rng(123)
|
||||
fs = 48000
|
||||
|
||||
# ~1 second of audio (kept small for test speed).
|
||||
n = fs
|
||||
x: StereoSignal = rng.normal(size=(n, 2)).astype(np.float64)
|
||||
|
||||
wav_path = tmp_path / "in.wav"
|
||||
sf.write(str(wav_path), x, fs)
|
||||
return wav_path
|
||||
|
||||
|
||||
def test_aac_coder_seq_schema_and_shapes(tmp_stereo_wav: Path) -> None:
|
||||
"""
|
||||
Module-level contract test:
|
||||
Ensure aac_seq_1 follows the expected schema and per-frame shapes.
|
||||
"""
|
||||
aac_seq: AACSeq1 = aac_coder_1(tmp_stereo_wav)
|
||||
|
||||
assert isinstance(aac_seq, list)
|
||||
assert len(aac_seq) > 0
|
||||
|
||||
for fr in aac_seq:
|
||||
assert isinstance(fr, dict)
|
||||
|
||||
# Required keys
|
||||
assert "frame_type" in fr
|
||||
assert "win_type" in fr
|
||||
assert "chl" in fr
|
||||
assert "chr" in fr
|
||||
|
||||
frame_type = fr["frame_type"]
|
||||
win_type = fr["win_type"]
|
||||
|
||||
assert frame_type in ("OLS", "LSS", "ESH", "LPS")
|
||||
assert win_type in ("SIN", "KBD")
|
||||
|
||||
assert isinstance(fr["chl"], dict)
|
||||
assert isinstance(fr["chr"], dict)
|
||||
assert "frame_F" in fr["chl"]
|
||||
assert "frame_F" in fr["chr"]
|
||||
|
||||
chl_f = np.asarray(fr["chl"]["frame_F"], dtype=np.float64)
|
||||
chr_f = np.asarray(fr["chr"]["frame_F"], dtype=np.float64)
|
||||
|
||||
if frame_type == "ESH":
|
||||
assert chl_f.shape == (128, 8)
|
||||
assert chr_f.shape == (128, 8)
|
||||
else:
|
||||
assert chl_f.shape == (1024, 1)
|
||||
assert chr_f.shape == (1024, 1)
|
||||
|
||||
|
||||
def test_end_to_end_aac_coder_decoder_high_snr(tmp_stereo_wav: Path, tmp_path: Path) -> None:
|
||||
"""
|
||||
End-to-end test:
|
||||
Encode + decode and check SNR is very high (numerical-noise only).
|
||||
|
||||
The threshold is intentionally loose to avoid fragility across platforms/BLAS.
|
||||
"""
|
||||
x_ref, fs = sf.read(str(tmp_stereo_wav), always_2d=True)
|
||||
x_ref = np.asarray(x_ref, dtype=np.float64)
|
||||
assert int(fs) == 48000
|
||||
|
||||
out_wav = tmp_path / "out.wav"
|
||||
|
||||
aac_seq = aac_coder_1(tmp_stereo_wav)
|
||||
x_hat: StereoSignal = aac_decoder_1(aac_seq, out_wav)
|
||||
|
||||
# Basic sanity: output file exists and is readable
|
||||
assert out_wav.exists()
|
||||
x_hat_file, fs_hat = sf.read(str(out_wav), always_2d=True)
|
||||
assert int(fs_hat) == 48000
|
||||
|
||||
# SNR against returned array (file should match closely, but we do not require it here).
|
||||
snr = _snr_db(x_ref, x_hat)
|
||||
assert snr > 80.0
|
||||
@@ -0,0 +1,269 @@
|
||||
# ------------------------------------------------------------
|
||||
# AAC Coder/Decoder - Filterbank Tests
|
||||
#
|
||||
# Multimedia course at Aristotle University of
|
||||
# Thessaloniki (AUTh)
|
||||
#
|
||||
# Author:
|
||||
# Christos Choutouridis (ΑΕΜ 8997)
|
||||
# cchoutou@ece.auth.gr
|
||||
#
|
||||
# Description:
|
||||
# Tests for Filterbank module.
|
||||
# ------------------------------------------------------------
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Sequence
|
||||
import pytest
|
||||
|
||||
from core.aac_filterbank import aac_filter_bank, aac_i_filter_bank
|
||||
from core.aac_types import *
|
||||
|
||||
# Helper fixtures for filterbank
|
||||
# -----------------------------------------------------------------------------
|
||||
|
||||
def _ola_reconstruct(x: StereoSignal, frame_types: Sequence[FrameType], win_type: WinType) -> StereoSignal:
|
||||
"""
|
||||
Analyze-synthesize each frame and overlap-add with hop=1024.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
x : StereoSignal
|
||||
Input stereo stream, expected shape (N, 2).
|
||||
frame_types : Sequence[FrameType]
|
||||
Length K sequence of frame types for frames starting at i*1024.
|
||||
win_type : WinType
|
||||
Window type ("SIN" or "KBD").
|
||||
|
||||
Returns
|
||||
-------
|
||||
StereoSignal
|
||||
Reconstructed stereo stream, same shape as x (N, 2).
|
||||
"""
|
||||
hop = 1024
|
||||
win = 2048
|
||||
K = len(frame_types)
|
||||
|
||||
y: StereoSignal = np.zeros_like(x, dtype=np.float64)
|
||||
|
||||
for i in range(K):
|
||||
start = i * hop
|
||||
frame_t: FrameT = x[start:start + win, :]
|
||||
frame_f: FrameF = aac_filter_bank(frame_t, frame_types[i], win_type)
|
||||
frame_t_hat: FrameT = aac_i_filter_bank(frame_f, frame_types[i], win_type)
|
||||
y[start:start + win, :] += frame_t_hat
|
||||
|
||||
return y
|
||||
|
||||
|
||||
def _snr_db(x: StereoSignal, y: StereoSignal) -> float:
|
||||
"""
|
||||
Compute SNR in dB over all samples/channels.
|
||||
"""
|
||||
err = x - y
|
||||
ps = float(np.sum(x * x))
|
||||
pn = float(np.sum(err * err))
|
||||
if pn <= 0.0:
|
||||
return float("inf")
|
||||
if ps <= 0.0:
|
||||
return float("-inf")
|
||||
return 10.0 * float(np.log10(ps / pn))
|
||||
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
# Forward filterbank tests
|
||||
# -----------------------------------------------------------------------------
|
||||
|
||||
@pytest.mark.parametrize("win_type", ["SIN", "KBD"])
|
||||
@pytest.mark.parametrize("frame_type", ["OLS", "LSS", "LPS"])
|
||||
def test_filterbank_shapes_long_sequences(frame_type: FrameType, win_type: WinType) -> None:
|
||||
"""
|
||||
Contract test: for OLS/LSS/LPS, aac_filter_bank returns shape (1024, 2).
|
||||
"""
|
||||
frame_t: FrameT = np.zeros((2048, 2), dtype=np.float64)
|
||||
frame_f = aac_filter_bank(frame_t, frame_type, win_type)
|
||||
assert frame_f.shape == (1024, 2)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("win_type", ["SIN", "KBD"])
|
||||
def test_filterbank_shapes_esh(win_type: WinType) -> None:
|
||||
"""
|
||||
Contract test: for ESH, aac_filter_bank returns shape (128, 16).
|
||||
"""
|
||||
frame_t: FrameT = np.zeros((2048, 2), dtype=np.float64)
|
||||
frame_f = aac_filter_bank(frame_t, "ESH", win_type)
|
||||
assert frame_f.shape == (128, 16)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("win_type", ["SIN", "KBD"])
|
||||
def test_filterbank_channel_isolation_long_sequences(win_type: WinType) -> None:
|
||||
"""
|
||||
Behavior test: for OLS (representative long-sequence), channels are independent.
|
||||
If right channel is zero and left is random, right spectrum should be near zero.
|
||||
"""
|
||||
rng = np.random.default_rng(0)
|
||||
frame_t: FrameT = np.zeros((2048, 2), dtype=np.float64)
|
||||
frame_t[:, 0] = rng.normal(size=2048)
|
||||
|
||||
frame_f = aac_filter_bank(frame_t, "OLS", win_type)
|
||||
|
||||
assert np.max(np.abs(frame_f[:, 1])) < 1e-9
|
||||
|
||||
|
||||
@pytest.mark.parametrize("win_type", ["SIN", "KBD"])
|
||||
def test_filterbank_channel_isolation_esh(win_type: WinType) -> None:
|
||||
"""
|
||||
Behavior test: for ESH, channels are independent.
|
||||
If right channel is zero and left is random, all odd columns (right) should be near zero.
|
||||
"""
|
||||
rng = np.random.default_rng(1)
|
||||
frame_t: FrameT = np.zeros((2048, 2), dtype=np.float64)
|
||||
frame_t[:, 0] = rng.normal(size=2048)
|
||||
|
||||
frame_f = aac_filter_bank(frame_t, "ESH", win_type)
|
||||
|
||||
right_cols = frame_f[:, 1::2] # columns 1,3,5,...,15
|
||||
assert np.max(np.abs(right_cols)) < 1e-9
|
||||
|
||||
|
||||
@pytest.mark.parametrize("win_type", ["SIN", "KBD"])
|
||||
def test_filterbank_esh_ignores_outer_regions(win_type: WinType) -> None:
|
||||
"""
|
||||
Spec-driven behavior test:
|
||||
ESH uses only the central region [448, 1600), split into 8 overlapping
|
||||
windows of length 256 with 50% overlap.
|
||||
|
||||
Therefore, changing samples outside [448, 1600) must not affect the output.
|
||||
"""
|
||||
rng = np.random.default_rng(2)
|
||||
|
||||
frame_a: FrameT = np.zeros((2048, 2), dtype=np.float64)
|
||||
frame_b: FrameT = np.zeros((2048, 2), dtype=np.float64)
|
||||
|
||||
center = rng.normal(size=(1152, 2))
|
||||
frame_a[448:1600, :] = center
|
||||
frame_b[448:1600, :] = center
|
||||
|
||||
frame_b[0:448, :] = rng.normal(size=(448, 2))
|
||||
frame_b[1600:2048, :] = rng.normal(size=(448, 2))
|
||||
|
||||
fa = aac_filter_bank(frame_a, "ESH", win_type)
|
||||
fb = aac_filter_bank(frame_b, "ESH", win_type)
|
||||
|
||||
# Use a tiny tolerance to avoid flaky failures due to floating-point minutiae.
|
||||
np.testing.assert_allclose(fa, fb, rtol=0.0, atol=1e-12)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("win_type", ["SIN", "KBD"])
|
||||
def test_filterbank_output_is_finite(win_type: WinType) -> None:
|
||||
"""
|
||||
Sanity test: output must not contain NaN or inf for representative cases.
|
||||
"""
|
||||
rng = np.random.default_rng(3)
|
||||
frame_t: FrameT = rng.normal(size=(2048, 2)).astype(np.float64)
|
||||
|
||||
for frame_type in ("OLS", "LSS", "ESH", "LPS"):
|
||||
frame_f = aac_filter_bank(frame_t, frame_type, win_type)
|
||||
assert np.isfinite(frame_f).all()
|
||||
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
# Reverse i_filterbank tests
|
||||
# -----------------------------------------------------------------------------
|
||||
|
||||
@pytest.mark.parametrize("win_type", ["SIN", "KBD"])
|
||||
def test_ifilterbank_shapes_long_sequences(win_type: WinType) -> None:
|
||||
"""
|
||||
Contract test: for OLS/LSS/LPS, aac_i_filter_bank returns shape (2048, 2).
|
||||
"""
|
||||
frame_f: FrameF = np.zeros((1024, 2), dtype=np.float64)
|
||||
for frame_type in ("OLS", "LSS", "LPS"):
|
||||
frame_t = aac_i_filter_bank(frame_f, frame_type, win_type)
|
||||
assert frame_t.shape == (2048, 2)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("win_type", ["SIN", "KBD"])
|
||||
def test_ifilterbank_shapes_esh(win_type: WinType) -> None:
|
||||
"""
|
||||
Contract test: for ESH, aac_i_filter_bank returns shape (2048, 2).
|
||||
"""
|
||||
frame_f: FrameF = np.zeros((128, 16), dtype=np.float64)
|
||||
frame_t = aac_i_filter_bank(frame_f, "ESH", win_type)
|
||||
assert frame_t.shape == (2048, 2)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("win_type", ["SIN", "KBD"])
|
||||
def test_roundtrip_per_frame_is_finite(win_type: WinType) -> None:
|
||||
"""
|
||||
Sanity test: per-frame analysis+synthesis must produce finite outputs.
|
||||
"""
|
||||
rng = np.random.default_rng(0)
|
||||
frame_t: FrameT = rng.normal(size=(2048, 2)).astype(np.float64)
|
||||
|
||||
for frame_type in ("OLS", "LSS", "ESH", "LPS"):
|
||||
frame_f = aac_filter_bank(frame_t, frame_type, win_type)
|
||||
frame_t_hat = aac_i_filter_bank(frame_f, frame_type, win_type)
|
||||
assert np.isfinite(frame_t_hat).all()
|
||||
|
||||
|
||||
@pytest.mark.parametrize("win_type", ["SIN", "KBD"])
|
||||
def test_ola_reconstruction_ols_high_snr(win_type: WinType) -> None:
|
||||
"""
|
||||
Module-level test:
|
||||
OLS analysis+synthesis with hop=1024 must reconstruct with high SNR
|
||||
in the steady-state region.
|
||||
"""
|
||||
rng = np.random.default_rng(1)
|
||||
|
||||
K = 6
|
||||
N = 1024 * (K + 1)
|
||||
x: StereoSignal = rng.normal(size=(N, 2)).astype(np.float64)
|
||||
|
||||
y = _ola_reconstruct(x, ["OLS"] * K, win_type)
|
||||
|
||||
a = 1024
|
||||
b = N - 1024
|
||||
snr = _snr_db(x[a:b, :], y[a:b, :])
|
||||
assert snr > 50.0
|
||||
|
||||
|
||||
@pytest.mark.parametrize("win_type", ["SIN", "KBD"])
|
||||
def test_ola_reconstruction_esh_high_snr(win_type: WinType) -> None:
|
||||
"""
|
||||
Module-level test:
|
||||
ESH analysis+synthesis with hop=1024 must reconstruct with high SNR
|
||||
in the steady-state region.
|
||||
"""
|
||||
rng = np.random.default_rng(2)
|
||||
|
||||
K = 6
|
||||
N = 1024 * (K + 1)
|
||||
x: StereoSignal = rng.normal(size=(N, 2)).astype(np.float64)
|
||||
|
||||
y = _ola_reconstruct(x, ["ESH"] * K, win_type)
|
||||
|
||||
a = 1024
|
||||
b = N - 1024
|
||||
snr = _snr_db(x[a:b, :], y[a:b, :])
|
||||
assert snr > 45.0
|
||||
|
||||
|
||||
@pytest.mark.parametrize("win_type", ["SIN", "KBD"])
|
||||
def test_ola_reconstruction_transition_sequence(win_type: WinType) -> None:
|
||||
"""
|
||||
Transition sequence test matching the windowing logic:
|
||||
OLS -> LSS -> ESH -> LPS -> OLS -> OLS
|
||||
"""
|
||||
rng = np.random.default_rng(3)
|
||||
|
||||
frame_types: list[FrameType] = ["OLS", "LSS", "ESH", "LPS", "OLS", "OLS"]
|
||||
K = len(frame_types)
|
||||
N = 1024 * (K + 1)
|
||||
x: StereoSignal = rng.normal(size=(N, 2)).astype(np.float64)
|
||||
|
||||
y = _ola_reconstruct(x, frame_types, win_type)
|
||||
|
||||
a = 1024
|
||||
b = N - 1024
|
||||
snr = _snr_db(x[a:b, :], y[a:b, :])
|
||||
assert snr > 40.0
|
||||
@@ -0,0 +1,117 @@
|
||||
# ------------------------------------------------------------
|
||||
# AAC Coder/Decoder - Filterbank internal (mdct) Tests
|
||||
#
|
||||
# Multimedia course at Aristotle University of
|
||||
# Thessaloniki (AUTh)
|
||||
#
|
||||
# Author:
|
||||
# Christos Choutouridis (ΑΕΜ 8997)
|
||||
# cchoutou@ece.auth.gr
|
||||
#
|
||||
# Description:
|
||||
# Tests for Filterbank internal MDCT/IMDCT functionality.
|
||||
# ------------------------------------------------------------
|
||||
from __future__ import annotations
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
from core.aac_filterbank import _imdct, _mdct
|
||||
from core.aac_types import FloatArray, TimeSignal, MdctCoeffs
|
||||
|
||||
|
||||
def _assert_allclose(a: FloatArray, b: FloatArray, *, rtol: float, atol: float) -> None:
|
||||
"""
|
||||
Helper for consistent tolerances across tests.
|
||||
"""
|
||||
np.testing.assert_allclose(a, b, rtol=rtol, atol=atol)
|
||||
|
||||
|
||||
def _estimate_gain(y: MdctCoeffs, x: MdctCoeffs) -> float:
|
||||
"""
|
||||
Estimate scalar gain g such that y ~= g*x in least-squares sense.
|
||||
"""
|
||||
denom = float(np.dot(x, x))
|
||||
if denom == 0.0:
|
||||
return 0.0
|
||||
return float(np.dot(y, x) / denom)
|
||||
|
||||
|
||||
tolerance = 1e-10
|
||||
|
||||
@pytest.mark.parametrize("N", [256, 2048])
|
||||
def test_mdct_imdct_mdct_identity_up_to_gain(N: int) -> None:
|
||||
"""
|
||||
Consistency test in coefficient domain:
|
||||
mdct(imdct(X)) ~= g * X
|
||||
|
||||
For the chosen (non-orthonormal) scaling, g is expected to be close to 2.
|
||||
"""
|
||||
rng = np.random.default_rng(0)
|
||||
K = N // 2
|
||||
|
||||
X: MdctCoeffs = rng.normal(size=K).astype(np.float64)
|
||||
x: TimeSignal = _imdct(X)
|
||||
X_hat: MdctCoeffs = _mdct(x)
|
||||
|
||||
g = _estimate_gain(X_hat, X)
|
||||
_assert_allclose(X_hat, g * X, rtol=tolerance, atol=tolerance)
|
||||
_assert_allclose(np.array([g], dtype=np.float64), np.array([2.0], dtype=np.float64), rtol=tolerance, atol=tolerance)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("N", [256, 2048])
|
||||
def test_mdct_linearity(N: int) -> None:
|
||||
"""
|
||||
Linearity test:
|
||||
mdct(a*x + b*y) == a*mdct(x) + b*mdct(y)
|
||||
"""
|
||||
rng = np.random.default_rng(1)
|
||||
x: TimeSignal = rng.normal(size=N).astype(np.float64)
|
||||
y: TimeSignal = rng.normal(size=N).astype(np.float64)
|
||||
|
||||
a = 0.37
|
||||
b = -1.12
|
||||
|
||||
left: MdctCoeffs = _mdct(a * x + b * y)
|
||||
right: MdctCoeffs = a * _mdct(x) + b * _mdct(y)
|
||||
|
||||
_assert_allclose(left, right, rtol=tolerance, atol=tolerance)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("N", [256, 2048])
|
||||
def test_imdct_linearity(N: int) -> None:
|
||||
"""
|
||||
Linearity test for IMDCT:
|
||||
imdct(a*X + b*Y) == a*imdct(X) + b*imdct(Y)
|
||||
"""
|
||||
rng = np.random.default_rng(2)
|
||||
K = N // 2
|
||||
|
||||
X: MdctCoeffs = rng.normal(size=K).astype(np.float64)
|
||||
Y: MdctCoeffs = rng.normal(size=K).astype(np.float64)
|
||||
|
||||
a = -0.5
|
||||
b = 2.0
|
||||
|
||||
left: TimeSignal = _imdct(a * X + b * Y)
|
||||
right: TimeSignal = a * _imdct(X) + b * _imdct(Y)
|
||||
|
||||
_assert_allclose(left, right, rtol=tolerance, atol=tolerance)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("N", [256, 2048])
|
||||
def test_mdct_imdct_outputs_are_finite(N: int) -> None:
|
||||
"""
|
||||
Sanity test: no NaN/inf on random inputs.
|
||||
"""
|
||||
rng = np.random.default_rng(3)
|
||||
K = N // 2
|
||||
|
||||
x: TimeSignal = rng.normal(size=N).astype(np.float64)
|
||||
X: MdctCoeffs = rng.normal(size=K).astype(np.float64)
|
||||
|
||||
X1 = _mdct(x)
|
||||
x1 = _imdct(X)
|
||||
|
||||
assert np.isfinite(X1).all()
|
||||
assert np.isfinite(x1).all()
|
||||
Reference in New Issue
Block a user