import pyroomacoustics as pra import numpy as np import random import json import os, glob import sofa import torch import torchaudio.transforms as AT from data.utils import read_audio_file from scipy.signal import convolve from scipy.ndimage import convolve1d import time class BaseSimulator(object): def __init__(self): pass def preprocess(self, audio): return audio def postprocess(self, audio): return audio def randomize_sources(self, num_sources): pass def get_metadata(self): metadata = {} metadata['duration'] = self.D metadata['sofa'] = self.sofa metadata['mic_positions'] = self.mic_positions metadata['sources'] = [] for i, source_id in enumerate(self.source_order): source = {'position':self.source_positions[i], 'order':source_id, 'hrtf_index':self.hrtf_indices[i], 'label':self.source_labels[i]} metadata['sources'].append(source) metadata['num_background'] = self.num_background_sources return metadata def save(self, path): metadata = self.get_metadata() with open(path, 'w') as f: json.dump(metadata, f, indent=4) def simulate(self, audio: np.ndarray) -> np.ndarray: """ Simulates RIR audio: (C x T) """ num_sources = audio.shape[0] #t1 = time.time() rirs = self.get_rirs() #t2 = time.time() #t_rir = t2 - t1 #t1 = time.time() x = self.preprocess(audio) output = [] for i in range(num_sources): rir = rirs[i] waveform = x[i] left = convolve(waveform, rir[0]) left = self.postprocess(left) right = convolve(waveform, rir[1]) right = self.postprocess(right) binaural = np.stack([left, right]) # Clean and renormalize so downstream sox int32 cast stays safe binaural = np.nan_to_num(binaural, nan=0.0, posinf=0.0, neginf=0.0) peak = np.max(np.abs(binaural)) if peak >= 1.0: binaural = binaural / (peak + 1e-8) binaural = np.clip(binaural, -0.9999999, 0.9999999) output.append(binaural) output = np.array(output, dtype=np.float32) #t2 = time.time() #t_convolve = t2 - t1 #print('RIR time:', t_rir) #print('Convolution time:', t_convolve) return output def initialize_room_with_random_params(self, num_sources: int, duration: float, ann_list: list, nbackground_sources: int = 1): self.D = duration self.source_labels = [] for i in range(num_sources): self.source_labels.append(ann_list[i]) # Randomize source choose order # First k sources correspond to background sources # Next n - k sources are foreground sources n = num_sources k = nbackground_sources self.source_order = [i for i in range(n - k)] np.random.shuffle(self.source_order) self.source_order = [i for i in range(n - k, n)] + self.source_order self.num_background_sources = k return self def seed(self, seed_value): np.random.seed(seed_value) random.seed(seed_value) class CATTRIR_Simulator(BaseSimulator): def __init__(self, dset_text_file, **kwargs) -> None: super().__init__() dset_dir = os.path.dirname(dset_text_file) with open(dset_text_file, 'r') as f: self.rt60_list = f.read().split('\n') self.rt60_dirs = [os.path.join(dset_dir, x) for x in self.rt60_list] def randomize_sources(self, num_sources): source_positions = [] hrtf_indices = [] rirs = sorted(os.listdir(self.room_dir)) random_source_rir_wavs = random.sample(rirs, num_sources) angles = [] for f in random_source_rir_wavs: angle = int(f[f.rfind('_')+1:-4]) angles.append(angle) for i in range(num_sources): pos = [np.cos(np.deg2rad(angle)), np.sin(np.deg2rad(angle))] source_positions.append(pos) hrtf_indices.append(angle) return source_positions, hrtf_indices def get_rirs(self): num_sources = len(self.source_positions) rt60 = os.path.basename(self.room_dir) rirs = [] for i in range(num_sources): path = os.path.join(self.room_dir, f'CATT_{rt60}_{self.hrtf_indices[i]}.wav') rir = read_audio_file(path, 44100) rirs.append(rir.astype(np.float32)) return rirs def initialize_room_with_random_params(self, num_sources: int, duration: float, ann_list: list, nbackground_sources: int = 1): self.room_dir = self.rt60_dirs[np.random.randint(len(self.rt60_dirs))] self.sofa = self.room_dir # TODO: Implement this better self.mic_positions = [[0, 0.9, 0], [0, -0.9, 0]] self.source_positions, self.hrtf_indices = self.randomize_sources(num_sources) return super().initialize_room_with_random_params(num_sources, duration, ann_list, nbackground_sources) class SOFASimulator(BaseSimulator): def __init__(self, sofa_text_file, **kwargs) -> None: super().__init__() self.hrtf_cache = {} self.sofa_dict = {} sofa_dir = os.path.dirname(sofa_text_file) with open(sofa_text_file, 'r') as f: raw_lines = f.read().splitlines() # Sanitize list: trim whitespace/CRLF, drop blanks and comments self.subject_sofa_list = [ line.strip() for line in raw_lines if line.strip() and not line.strip().startswith('#') ] # Resolve paths relative to list file directory; normalize and validate self.sofa_files = [] for entry in self.subject_sofa_list: path = entry if os.path.isabs(entry) else os.path.join(sofa_dir, entry) path = os.path.normpath(path) if not os.path.exists(path): raise FileNotFoundError( f"SOFA file listed in {sofa_text_file} not found: {repr(path)}" ) self.sofa_files.append(path) for fpath in self.sofa_files: self.sofa_dict[fpath] = sofa.Database.open(fpath) self.kwargs = kwargs def initialize_room_with_random_params(self, num_sources: int, duration: float, ann_list: list, nbackground_sources: int = 1): self.sofa = self.sofa_files[np.random.randint(len(self.sofa_files))] self.HRTF = self.sofa_dict[self.sofa]#sofa.Database.open(self.sofa) mic_positions = self.HRTF.Receiver.Position.get_values(system="cartesian")[..., 0] self.mic_positions = mic_positions.tolist() self.source_positions, self.hrtf_indices = self.randomize_sources(num_sources) return super().initialize_room_with_random_params(num_sources, duration, ann_list, nbackground_sources) def get_rirs(self): num_sources = len(self.source_positions) rirs = [] for i in range(num_sources): key = self.sofa + str(sorted(list(self.hrtf_indices[i].items()))) #print('KEY', key) if key in self.hrtf_cache: rir = self.hrtf_cache[key] else: rir = self.HRTF.Data.IR.get_values(indices=self.hrtf_indices[i]).astype(np.float32) self.hrtf_cache[key] = rir.copy() rirs.append(rir) return rirs class CIPIC_Simulator(SOFASimulator): def randomize_sources(self, num_sources): source_positions = [] hrtf_indices = [] random_source_positions = random.sample(range(self.HRTF.Dimensions.M), num_sources) for i in range(num_sources): sofa_indices = {"M":random_source_positions[i]} pos = self.HRTF.Source.Position.get_values(system="cartesian", indices=sofa_indices).tolist() source_positions.append(pos) hrtf_indices.append(sofa_indices) return source_positions, hrtf_indices class CIPIC_HRTF_Simulator(CIPIC_Simulator): pass class BRIR48kHz_Simulator(CIPIC_HRTF_Simulator): def __init__(self, sofa_text_file, **kwargs): super().__init__(sofa_text_file, **kwargs) self.presampler = AT.Resample(self.kwargs['sr'], 48000) self.postsampler = AT.Resample(48000, self.kwargs['sr']) def preprocess(self, audio: np.ndarray) -> np.ndarray: audio = self.presampler(torch.from_numpy(audio)) return audio.numpy() def postprocess(self, audio: np.ndarray) -> np.ndarray: audio = self.postsampler(torch.from_numpy(audio)) return audio.numpy() # Salford-BBC Spatially-sampled Binaural Room Impulse Responses # https://usir.salford.ac.uk/id/eprint/30868/ class SBSBRIR_Simulator(BRIR48kHz_Simulator): def randomize_sources(self, num_sources): source_positions = [] hrtf_indices = [] random_source_positions = random.sample(range(self.HRTF.Dimensions.E), num_sources) random_measurement_rotation = np.random.randint(self.HRTF.Dimensions.M) for i in range(num_sources): #sofa_indices = {"M":0, "E":0} sofa_indices = {"M":random_measurement_rotation, "E":random_source_positions[i]} pos = self.HRTF.Emitter.Position.get_values(system="cartesian", indices=sofa_indices).tolist() source_positions.append(pos) hrtf_indices.append(sofa_indices) return source_positions, hrtf_indices def preprocess(self, audio: np.ndarray) -> np.ndarray: audio = super().preprocess(audio) audio = audio * 15 return audio # Gain because RIRs are very low for some reason # Real Room BRIRs # https://github.com/IoSR-Surrey/RealRoomBRIRs class RRBRIR_Simulator(BRIR48kHz_Simulator): pass class Multi_Ch_Simulator(BaseSimulator): # simulators = [CIPIC_Simulator] # simulators = [ CATTRIR_Simulator] # simulators = [ SBSBRIR_Simulator] # simulators = [RRBRIR_Simulator] # simulators = [SBSBRIR_Simulator, RRBRIR_Simulator, CATTRIR_Simulator] # UNCOMMENT FOR REVERBED HRTF ONLY def __init__(self, hrtf_dir, dset_type: str, sr: int, reverb: bool = True) -> None: self.hrtf_dir = hrtf_dir self.dset = dset_type self.sr = sr if reverb: simulators = [CIPIC_Simulator, SBSBRIR_Simulator, RRBRIR_Simulator, CATTRIR_Simulator] else: simulators = [CIPIC_Simulator] #simulators = [SBSBRIR_Simulator] self.simulators = [sim(os.path.join(self.hrtf_dir, sim.__name__[:-len("_Simulator")], self.dset + '_hrtf.txt'), sr=self.sr) for sim in simulators] def get_random_simulator(self) -> BaseSimulator: sim = random.choice(self.simulators) #print("Using simulator", type(sim)) return sim#(os.path.join(self.hrtf_dir, sim.__name__[:-len("_Simulator")], self.dset + '_hrtf.txt'),sr=self.sr) class PRASimulator(object): def __init__(self, n_mics = 2, min_absorption=0.6, max_absorption=1, fs=44100, max_order=15, mean_mic_distance=13.9, mic_distance_var=0.7, mic_array_keepout=0.5, min_room_length=6, max_room_length=8, min_room_width=6, max_room_width=8) -> None: """ Mic distance is by default the average of the median Bitragion Breadth for men and women """ # Constant across samples self.M = n_mics self.fs = fs self.K = mic_array_keepout self.max_order = max_order self.min_absorption = min_absorption self.max_absorption = max_absorption self.R = mean_mic_distance self.V = mic_distance_var self.min_room_length = min_room_length self.max_room_length = max_room_length self.min_room_width = min_room_width self.max_room_width = max_room_width def initialize_room_with_random_params(self, num_sources: int, duration: float): self.D = duration self.mic_distance = np.random.normal(self.R, scale=self.V ** 0.5) * 1e-2 self.mic_positions = [[-self.mic_distance/2, 0], [self.mic_distance/2, 0]] self.absorption = np.random.uniform(self.min_absorption, self.max_absorption) self.L = np.random.uniform(self.min_room_length, self.max_room_length) self.W = np.random.uniform(self.min_room_width, self.max_room_width) self.left_wall = -self.L / 2 self.right_wall = self.L / 2 self.bottom_wall = -self.W / 2 self.top_wall = self.W / 2 self.source_positions = [] for i in range(num_sources): source_pos = self._get_random_source_pos(self.left_wall, self.right_wall, self.bottom_wall, self.top_wall, self.K) self.source_positions.append(source_pos) # Randomize source choose order self.source_order = [i for i in range(num_sources - 1)] np.random.shuffle(self.source_order) self.source_order = [num_sources-1] + self.source_order # Background is always last return self def intialize_from_metadata(self, metadata_path): with open(metadata_path, 'r') as f: metadata = json.load(f) self.D = metadata['duration'] self.M = metadata['n_mics'] self.fs = metadata['sampling_rate'] self.max_order = metadata['max_order'] self.absorption = metadata['absorption'] self.mic_distance = metadata['mic_distance'] self.mic_positions = metadata['mic_positions'] room_desc = metadata['room'] self.L = room_desc['length'] self.W = room_desc['width'] self.left_wall = -self.L / 2 self.right_wall = self.L / 2 self.bottom_wall = -self.W / 2 self.top_wall = self.W / 2 self.source_order = [] self.source_positions = [] source_list = metadata['sources'] for source in source_list: source_id = source['order'] source_position = source['position'] self.source_order.append(source_id) self.source_positions.append(source_position) return self def get_metadata(self): metadata = {} metadata['duration'] = self.D metadata['sampling_rate'] = self.fs metadata['max_order'] = self.max_order metadata['n_mics'] = self.M metadata['absorption'] = self.absorption metadata['mic_distance'] = self.mic_distance metadata['mic_positions'] = self.mic_positions room_desc = {} room_desc['length'] = self.L room_desc['width'] = self.W metadata['room'] = room_desc metadata['sources'] = [] for i, source_id in enumerate(self.source_order): source = {'position':self.source_positions[i], 'order':source_id} metadata['sources'].append(source) return metadata def save(self, path): metadata = self.get_metadata() with open(path, 'w') as f: json.dump(metadata, f, indent=4) def simulate(self, source_audio): """ Input: list of source_audio (T,) returns y (M, T) """ corners = np.array([[self.left_wall, self.bottom_wall], [self.right_wall, self.bottom_wall], [self.right_wall, self.top_wall], [self.left_wall, self.top_wall]]).T room = pra.room.Room.from_corners(corners, absorption=self.absorption, fs=self.fs, max_order=self.max_order) mic_array = np.array(self.mic_positions).T#pra.circular_2D_array(center=[0., 0.], M=self.M, phi0=180, radius=self.mic_distance * 0.5 * 1e-2) room.add_microphone_array(mic_array) for i, source_pos in enumerate(self.source_positions): room.add_source(source_pos, signal=source_audio[i]) y = room.simulate(return_premix=True) total_samples = int(round(self.D * self.fs)) return y[..., :total_samples] def _get_random_source_pos(self, L, R, B, T, K): pos = [0, 0] while np.linalg.norm(pos) < K: x = np.random.uniform(L, R) y = np.random.uniform(B, T) pos = [x, y] return pos def test(): n_sources = 5 duration = 1 save_path = 'mymetadata.json' simulator = PRASimulator().initialize_room_with_random_params(n_sources, duration) simulator.save(save_path) simulator2 = PRASimulator().intialize_from_metadata(save_path) x = [np.random.random(44100) for i in range(n_sources)] # x = [np.sin(2 * np.pi * 440 * np.arange(0, 1, 1/44100)) for i in range(n_sources)] y = simulator2.simulate(x) * 1e3 import soundfile as sf sf.write('audio.wav', y[0].T, 44100) if __name__ == "__main__": test()