goonj 1.4.3

Goonj — acoustics engine for sound propagation, room simulation, and impulse response generation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! dhvani integration — IR handoff for convolution reverb.
//!
//! Provides [`DhvaniIr`], a wrapper around [`ImpulseResponse`]
//! with additional metadata that dhvani needs for convolution reverb processing.

use crate::impulse::{ImpulseResponse, IrConfig, MultibandIr, generate_ir, sabine_rt60};
use crate::room::AcousticRoom;
use hisab::Vec3;
use serde::{Deserialize, Serialize};

/// An impulse response packaged for dhvani's convolution reverb engine.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DhvaniIr {
    /// The broadband impulse response.
    pub ir: ImpulseResponse,
    /// Per-band impulse responses (optional, for frequency-dependent reverb).
    pub multiband: Option<MultibandIr>,
    /// Room volume in m³.
    pub room_volume: f32,
    /// Per-band RT60 estimates in seconds.
    pub rt60_bands: [f32; crate::material::NUM_BANDS],
}

/// Generate an IR ready for dhvani consumption.
#[must_use]
#[tracing::instrument(skip(room, config), fields(
    sample_rate = config.sample_rate,
))]
pub fn generate_dhvani_ir(
    source: Vec3,
    listener: Vec3,
    room: &AcousticRoom,
    config: &IrConfig,
) -> DhvaniIr {
    let multiband = generate_ir(source, listener, room, config);
    let broadband = multiband.to_broadband();
    let volume = room.geometry.volume_shoebox();

    // Estimate per-band RT60 using Sabine with per-band absorption
    let rt60_bands = std::array::from_fn(|band| {
        let total_abs: f32 = room
            .geometry
            .walls
            .iter()
            .map(|w| w.area() * w.material.absorption[band])
            .sum();
        if total_abs > 0.0 {
            sabine_rt60(volume, total_abs)
        } else {
            f32::INFINITY
        }
    });

    DhvaniIr {
        ir: broadband,
        multiband: Some(multiband),
        room_volume: volume,
        rt60_bands,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::material::AcousticMaterial;

    #[test]
    fn dhvani_ir_has_valid_data() {
        let room = AcousticRoom::shoebox(10.0, 8.0, 3.0, AcousticMaterial::concrete());
        let config = IrConfig {
            num_diffuse_rays: 100,
            max_time_seconds: 0.2,
            ..IrConfig::default()
        };
        let ir = generate_dhvani_ir(
            Vec3::new(3.0, 1.5, 4.0),
            Vec3::new(7.0, 1.5, 4.0),
            &room,
            &config,
        );
        assert!(!ir.ir.samples.is_empty());
        assert!(ir.room_volume > 0.0);
        assert!(ir.multiband.is_some());
        for &rt in &ir.rt60_bands {
            assert!(rt > 0.0, "RT60 should be positive");
        }
    }

    #[test]
    fn dhvani_ir_serializes() {
        let room = AcousticRoom::shoebox(5.0, 4.0, 3.0, AcousticMaterial::concrete());
        let config = IrConfig {
            num_diffuse_rays: 10,
            max_time_seconds: 0.05,
            ..IrConfig::default()
        };
        let ir = generate_dhvani_ir(
            Vec3::new(2.5, 1.5, 2.0),
            Vec3::new(2.5, 1.5, 2.0 + 0.5),
            &room,
            &config,
        );
        let json = serde_json::to_string(&ir);
        assert!(json.is_ok(), "should serialize to JSON");
    }

    #[test]
    fn dhvani_ir_zero_absorption_band_infinite_rt60() {
        // Material with zero absorption at band 0 → RT60 infinite for that band
        let mat = AcousticMaterial::new("zero_low", [0.0, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6], 0.1)
            .unwrap();
        let room = AcousticRoom::shoebox(5.0, 4.0, 3.0, mat);
        let config = IrConfig {
            num_diffuse_rays: 10,
            max_time_seconds: 0.05,
            ..IrConfig::default()
        };
        let ir = generate_dhvani_ir(
            Vec3::new(2.5, 1.5, 2.0),
            Vec3::new(2.5, 1.5, 2.0 + 0.5),
            &room,
            &config,
        );
        assert!(
            ir.rt60_bands[0].is_infinite(),
            "zero absorption band should give infinite RT60"
        );
    }
}