def __init__(self):

# --- MODIFIED: Audio Configuration ---

self.sample_rate = 5000

# self.sample_rate = 12000

self.block_size = 512

self.num_speakers = 256

self.output_filename = "spatial_audio_output2.wav"

self.wav_file = None

self.gain_slider = None

self.cuda_stream = torch.cuda.Stream(priority=-2)

print(f"Initializing Engine: {self.num_speakers} Speakers @ {self.sample_rate}Hz")

self.audio_engine = RealtimeSpatialPulseEngine(

sample_rate=self.sample_rate, block_size=self.block_size, num_speakers=self.num_speakers,

stream=self.cuda_stream

)

self._outdata_tensor = torch.empty(

(self.block_size, 2),

dtype=torch.float32,

device="cpu"

)

self.stream = None

# Frequency control state

self.freq_x, self.freq_y = 50.0, 50.0

# Speaker position state (X, Y, Z)

self.speaker_x_percent, self.speaker_z_percent = 50.0, 75.0

self.speaker_y_percent = 50.0 # Default middle height

# Head position state (X, Y, Z)

self.head_x_percent, self.head_z_percent = 50.0, 50.0

self.head_y_percent = 50.0 # Default middle height

# Other audio parameters

self.pulse_rate, self.pulse_decay = 1.0, 5.0

self.root = tk.Tk()

self.point_size = 8

self.tracking_mode = False

self.last_valid_point = None

self.last_valid_rotation = None

self.tracker_connected = True

self.setup_ui()

# --- NEW: Setup ACEG Swarm ---

self._set_initial_spatial_chord()

self.start_audio()

self.update_display_loop()

# --- NEW: Frequency Helper Methods ---

def _freq_to_erb(self, freq):

"""Converts frequency (Hz) to the ERB scale."""

return 21.4 * math.log10(1 + 0.00437 * freq)

def _freq_to_percent(self, freq):

"""Converts frequency (Hz) to the 0-100% Y-axis value."""

min_f, max_f = 20.0, min(20000.0, self.sample_rate / 2)

min_e = self._freq_to_erb(min_f)

max_e = self._freq_to_erb(max_f)

erb = max(min_e, min(max_e, self._freq_to_erb(freq)))

return (erb - min_e) / (max_e - min_e) * 100.0

def _set_initial_spatial_chord(self):

"""Sets up 256 speakers with ACEG notes (30Hz-20kHz) and randomized phases."""

print(f"Generating ACEG Chord Spectrum (30Hz-20kHz)...")

# 1. Generate Valid ACEG Notes

valid_freqs = []

base_a = 27.5/2

for octave in range(6):

octave_base = base_a * (2 ** octave)

# Intervals: 0(A), 3(C), 7(E), 10(G)

for semitone in [3, 7, 10]:

freq = octave_base * (2 ** (semitone / 12.0))

if 30.0 <= freq <= 20000.0:

valid_freqs.append(freq)

# 2. Assign Frequencies

freq_x = np.random.uniform(40.0, 60.0, self.num_speakers)

freq_y = np.zeros(self.num_speakers)

rng = np.random.default_rng()

for i in range(self.num_speakers):

note_freq = valid_freqs[i % len(valid_freqs)]

# Slight detune (+/- 0.2%)

detune = 1.0 + rng.uniform(-0.002, 0.002)

freq_y[i] = self._freq_to_percent(note_freq * detune)

# Apply Frequencies

coords = torch.from_numpy(np.stack([freq_x, freq_y], axis=1)).to(

device=self.audio_engine.device, dtype=self.audio_engine.dtype

)

self.audio_engine.set_frequency_targets(coords)

self.freq_x, self.freq_y = freq_x[0], freq_y[0]

# 3. Randomize Pulse Phases (0.0s - 0.5s)

pulse_rate = 1.0

random_delays = torch.rand(self.num_speakers, device=self.audio_engine.device) * 0.5

self.audio_engine.pulse_phase[:] = random_delays * pulse_rate * (2 * np.pi)

self.audio_engine.pulse_decay_rate[:] = 2.3

self.audio_engine.pulse_rate_hz[:] = 0.5

# 4. Set Spatial Positions (Spiral Layout)

room_dims = self.audio_engine.space_effect.room_dimensions.cpu().numpy()

positions = np.zeros((self.num_speakers, 3))

for i in range(self.num_speakers):

theta = i * 2.3999632 # Golden Angle

r = 2.0 + (i / self.num_speakers) * 12.0

wx = r * np.cos(theta)

wz = r * np.sin(theta)

px = (wx / (room_dims[0] / 2) + 1.0) * 50.0

pz = (wz / (room_dims[2] / 2) + 1.0) * 50.0

self.audio_engine.set_speaker_position(i, px, pz, pz)

positions[i] = [wx, 0.0, wz]

# 5. Amplitude Normalization

head_pos = torch.zeros(3, device=self.audio_engine.device, dtype=self.audio_engine.dtype)

spk_pos = torch.from_numpy(positions).to(device=self.audio_engine.device, dtype=self.audio_engine.dtype)

estimated_gains = self.audio_engine.space_effect.estimate_peak_gain(head_pos, spk_pos)

linear_amps = torch.clamp(1.0 / (estimated_gains + 1e-6), min=0.01, max=5.0) * 0.2

self.audio_engine.set_amplitudes(linear_amps)

# --- MODIFIED: Audio Callback ---

def audio_callback(self, outdata, frames, time, status):

with torch.cuda.stream(self.cuda_stream):

out = self.audio_engine.process(frames)

# --- MODIFIED: Mean and Gain Boost ---

# Take mean across speakers (Dim 0) -> (Frames, 2)

# Multiply by 20.0 to fix silence

out_mixed = out.mean(dim=0) * 20.0

self._outdata_tensor.data = torch.from_numpy(outdata)

self.cuda_stream.synchronize()

self._outdata_tensor.copy_(out_mixed, non_blocking=False)

# --- MODIFIED: Save to file ---

if self.wav_file:

self.wav_file.write(outdata)

return outdata

# --- MODIFIED: Start Audio ---

def start_audio(self):

# Open file

try:

self.wav_file = sf.SoundFile(

self.output_filename, mode='w', samplerate=self.sample_rate,

channels=2, subtype='FLOAT'

)

print(f"Recording to: {self.output_filename}")

except Exception as e:

print(f"File Error: {e}")

self.stream = sd.OutputStream(samplerate=self.sample_rate, channels=2,

blocksize=self.block_size, dtype=np.float32,

latency='low', callback=self.audio_callback)

self.stream.start()

print(f"Audio Engine Started: {self.sample_rate}Hz, {self.block_size} samples")

# --- MODIFIED: On Closing ---

def on_closing(self):

print("Closing...")

if self.stream:

self.stream.stop()

self.stream.close()

if self.wav_file:

self.wav_file.close()

print(f"File saved: {self.output_filename}")

self.root.destroy()

def run(self):

self.root.mainloop()

# =========================================================================

# ORIGINAL UI METHODS BELOW (Unchanged)

# =========================================================================

def create_grid_canvas_with_labels(self, parent, title, width=280, height=280,

highlight_color='#00ffff', grid_color='#006666',

x_label="X", y_label="Y"):

"""Create a compact labeled grid canvas."""

frame = tk.Frame(parent, bg='#0a0a0a')

# Title - more compact

title_widget = tk.Label(frame, text=title, font=('Arial', 11, 'bold'),

fg='#ffffff', bg='#0a0a0a')

title_widget.pack(pady=(0, 3))

# Canvas with axis labels

canvas_frame = tk.Frame(frame, bg='#0a0a0a')

canvas_frame.pack()

# Y-axis label (left side, vertical)

y_label_widget = tk.Label(canvas_frame, text=y_label, font=('Arial', 8),

fg='#888888', bg='#0a0a0a', width=8, anchor='e')

y_label_widget.pack(side='left', padx=(0, 2))

# Canvas container

canvas_col = tk.Frame(canvas_frame, bg='#0a0a0a')

canvas_col.pack(side='left')

# Main canvas - smaller size

canvas = tk.Canvas(canvas_col, width=width, height=height, bg='#111111',

highlightthickness=1, highlightbackground=highlight_color)

canvas.pack()

# X-axis label (bottom)

x_label_widget = tk.Label(canvas_col, text=x_label, font=('Arial', 8),

fg='#888888', bg='#0a0a0a')

x_label_widget.pack(pady=(1, 0))

# Draw grid with more lines for better precision

self.draw_grid(canvas, color=grid_color, width=width, height=height)

# Store for dynamic updates

canvas.x_label_widget = x_label_widget

canvas.y_label_widget = y_label_widget

return frame, canvas

def create_controllable_point(self, canvas, x_percent, y_percent, color='#ff6b6b',

click_callback=None, drag_callback=None):

"""Create a draggable point on a canvas."""

canvas_x, canvas_y = self.grid_to_canvas(x_percent, y_percent)

point = canvas.create_oval(canvas_x - self.point_size, canvas_y - self.point_size,

canvas_x + self.point_size, canvas_y + self.point_size,

fill=color, outline='#ffffff', width=2)

if click_callback:

canvas.bind('<Button-1>', click_callback)

if drag_callback:

canvas.bind('<B1-Motion>', drag_callback)

return point

def setup_ui(self):

self.root.title("Hyper-Realistic Spatial Audio Engine v9 [HRIR + Reverb]")

self.root.configure(bg='#0a0a0a')

self.root.geometry("1200x900")

main_frame = tk.Frame(self.root, bg='#0a0a0a')

main_frame.pack(fill='both', expand=True, padx=20, pady=20)

# Title

title_label = tk.Label(main_frame, text="Real-time Physical Acoustics + Spatial Audio Simulation",

font=('Arial', 18, 'bold'), fg='#00ffff', bg='#0a0a0a')

title_label.pack(pady=(0, 10))

tracking_frame = tk.Frame(main_frame, bg='#1a1a1a')

tracking_frame.pack(fill='x', pady=5)

# Tracking mode toggle

self.tracking_button = tk.Button(

tracking_frame,

text="TRACKING MODE: ON",

font=('Arial', 12, 'bold'),

fg='#00ff00',

bg='#222222',

activebackground='#333333',

command=self.toggle_tracking_mode,

width=25

)

self.tracking_button.pack(side='left', padx=10)

# Connection status

self.connection_label = tk.Label(

tracking_frame,

text="● CONNECTED",

font=('Arial', 12, 'bold'),