def gen_audio_stim(MatrixDir, OutDir, indexes): if os.path.exists(OutDir): shutil.rmtree(OutDir) os.makedirs(OutDir) wavFiles = globDir(MatrixDir, '*.wav') wavFileMatrix = organiseWavs(wavFiles) wavDir = os.path.join(OutDir, "wav") dir_must_exist(wavDir) wavDir = os.path.join(wavDir, "noise-sentences") dir_must_exist(wavDir) files = [] n = 0 o = 0 for sentenceList in indexes: n += 1 o = 0 files.append([]) for ind in sentenceList: o += 1 y, wavInfo, partnames = synthesize_trial(wavFileMatrix, ind) fileName = os.path.join(wavDir, 'Trial_{0:02d}_{1:02d}.wav'.format(n, o)) print("Generating: " + fileName) sndio.write(fileName, y, **wavInfo) files[-1].append(fileName) return files
def gen_rms_peak(files, OutRMSDir, OutPeakDir): rmsFiles = [] peakFiles = [] for file in files: head, tail = os.path.split(file) tail = os.path.splitext(tail)[0] tail = tail + "_rms.npy" dir_must_exist(OutRMSDir) rmsFilepath = os.path.join(OutRMSDir, tail) print("Generating: " + rmsFilepath) y, fs, _ = sndio.read(file) y_rms = window_rms(y, round(0.02 * fs)) np.save(rmsFilepath, y_rms) rmsFiles.append(rmsFilepath) head, tail = os.path.split(file) tail = os.path.splitext(tail)[0] tail = tail + "_peak.npy" dir_must_exist(OutPeakDir) peakFilepath = os.path.join(OutPeakDir, tail) print("Generating: " + peakFilepath) peak = np.abs(y).max() np.save(peakFilepath, peak) peakFiles.append(peakFilepath) return rmsFiles, peakFiles
def gen_noise(OutDir, b, fs): print("Generating noise...") # Generate 10 minutes of white noise x = np.random.randn(int(fs * 60. * 5.)) x /= x.max() noiseDir = os.path.join(OutDir, 'wav') noiseRMSDir = os.path.join(OutDir, 'rms') dir_must_exist(noiseDir) noiseDir = os.path.join(noiseDir, 'noise') dir_must_exist(noiseDir) y, y_max = block_lfilter_wav(b, [1.0], x, os.path.join(noiseDir, 'noise.wav'), 65538, 44100) block_process_wav(os.path.join(noiseDir, 'noise.wav'), os.path.join(noiseDir, 'noise_norm.wav'), lambda x: x / (y_max * 1.05)) noise_norm_wav = PySndfile(os.path.join(noiseDir, 'noise_norm.wav'), 'r') noise_rms_path = os.path.join(noiseRMSDir, 'noise_rms.npy') y = noise_norm_wav.read_frames(fs * 60) y = y / (np.abs(y).max() * 0.95) # rms = np.sqrt(np.mean(y**2)) # rms, _, _ = asl_P56(y, fs, 16) rms = rms_no_silences(y, fs, -30.) print(f"Noise level: {rms}") peak = np.abs(y).max() np.save(noise_rms_path, rms) np.save('./stimulus/peak/noise_peak.npy', peak) return y
def generate_folder_hierachy(self): ''' ''' sub_dirs = [ "mat_test", "tone_test", "pta", "click_test", "info", "eeg_story_train", "eeg_mat_train", "eeg_test", "eeg_test/stimulus", "parameters" ] for dir_name in sub_dirs: dn = os.path.join(*dir_name.split('/')) path = os.path.join(self.participant_dir, dn) dir_must_exist(path) self.data_paths[dir_name] = path
def gen_rms(file, OutDir): head, tail = os.path.split(file) tail = os.path.splitext(tail)[0] tail = tail + "_env.npy" dir_must_exist(OutDir) rmsFilepath = os.path.join(OutDir, tail) print("Generating: " + rmsFilepath) y, fs, _ = sndio.read(file) y = y[:, 0] y_rms = window_rms(y, round(0.02 * fs)) np.save(rmsFilepath, y_rms) return rmsFilepath
def __init__(self, participant_dir=None, number=None, age=None, gender=None, handedness=None, general_notes=None, parameters={}, gen_time=datetime.now()): ''' ''' dir_must_exist(participant_dir) self.participant_dir = participant_dir self.data_paths = {} self.generate_folder_hierachy() self.parameters = parameters self.gen_time = gen_time self.data = { "info": { "number": number, "age": age, "gender": gender, "handedness": handedness, "general_notes": general_notes }, "mat_test": { "notes": '' }, "eeg_story_train": { "notes": '' }, "eeg_mat_train": { "notes": '' }, "eeg_test": { "notes": '' }, "tone_test": { "notes": '' }, "click_test": { "notes": '' }, "pta": { "notes": '' } } self.data['parameters'] = parameters
def gen_noise(OutDir, b, fs, s_rms): print("Generating noise...") # Generate 10 minutes of white noise x = np.random.randn(int(fs * 60. * 20.)) x /= x.max() noiseDir = os.path.join(OutDir, 'wav') noiseRMSDir = os.path.join(OutDir, 'rms') dir_must_exist(noiseDir) noiseDir = os.path.join(noiseDir, 'noise') dir_must_exist(noiseDir) y, y_max = block_lfilter_wav(b, [1.0], x, os.path.join(noiseDir, 'noise.wav'), 65538, 44100) block_process_wav(os.path.join(noiseDir, 'noise.wav'), os.path.join(noiseDir, 'noise_norm.wav'), lambda x: x / (y_max * 0.95)) y = y / (np.abs(y).max() * 0.95) noise_rms_path = os.path.join(noiseRMSDir, 'noise_rms.npy') rms = np.sqrt(np.mean(y**2)) np.save(noise_rms_path, rms) return y
def generate_audio_stimulus(MatrixDir, OutDir, indexes, socketio=None): # Get matrix wav file paths wavFiles = globDir(MatrixDir, '*.wav') wavFileMatrix = organiseWavs(wavFiles) wav_dir = os.path.join(args['OutDir'], "wav") dir_must_exist(wav_dir) sentence_dir = os.path.join(wav_dir, "sentence-lists") dir_must_exist(sentence_dir) # Synthesize audio for each trial using generated word choices sentence_lists = {} for key in indexes.keys(): files = [] list_dir = os.path.join(sentence_dir, key) dir_must_exist(list_dir) with open(os.path.join(list_dir, 'stim_parts.csv'), 'w') as csvfile: partwriter = csv.writer(csvfile) inds, strings = indexes[key] for sentence_ind, (component_inds, component_strings) in enumerate( zip(inds, strings)): if socketio: percent = (l / Length) * 100. socketio.emit('update-progress', {'data': '{}%'.format(percent)}, namespace='/main') y, wavInfo, partnames = synthesize_trial( wavFileMatrix, component_inds) partwriter.writerow(component_strings) file_name = os.path.join( list_dir, 'Trial_{0:05d}.wav'.format(sentence_ind + 1)) sndio.write(file_name, y, **wavInfo) files.append(file_name) sentence_lists[key] = np.array(files) return sentence_lists
def main(): ''' ''' fs = 44100 f = 1000.0 n = np.arange(fs * 60 * 5) y = np.sin(2 * np.pi * f * n / fs) coef = np.load('./out/calibration_coefficients/click_cal_coef.npy') y *= coef dir_must_exist('./out/calibrated_stim/') sndio.write("./out/calibrated_stim/1k_tone.wav", y, fs, format='wav', enc='pcm16') coef = np.load('./out/calibration_coefficients/da_cal_coef.npy') y, fs, enc = sndio.read('./out/stimulus/da_cal_stim.wav') sndio.write('./out/calibrated_stim/da_cal_stim.wav', y * coef, fs, format='wav', enc='pcm16') coef = np.load('./out/calibration_coefficients/mat_cal_coef.npy') y, fs, enc = sndio.read('./out/stimulus/mat_cal_stim.wav') sndio.write('./out/calibrated_stim/mat_cal_stim.wav', y * coef, fs, format='wav', enc='pcm16') coef = np.load('./out/calibration_coefficients/story_cal_coef.npy') y, fs, enc = sndio.read('./out/stimulus/story_cal_stim.wav') sndio.write('./out/calibrated_stim/story_cal_stim.wav', y * coef, fs, format='wav', enc='pcm16')
def gen_rms(files, OutDir): rmsFiles = [] OutPeakDir = './stimulus/peak' for sentenceList in files: for file in sentenceList: head, tail = os.path.split(file) tail = os.path.splitext(tail)[0] tail_rms = tail + "_rms.npy" dir_must_exist(OutDir) rmsFilepath = os.path.join(OutDir, tail_rms) print("Generating: " + rmsFilepath) y, fs, _ = sndio.read(file) y_rms = calc_rms(y, round(0.02 * fs)) np.save(rmsFilepath, y_rms) rmsFiles.append(rmsFilepath) y, fs, _ = sndio.read(file) tail_peak = tail + "_peak.npy" dir_must_exist(OutPeakDir) peakFilepath = os.path.join(OutPeakDir, tail_peak) print("Generating: " + peakFilepath) peak = np.abs(y).max() np.save(peakFilepath, peak) return rmsFiles
def main(): ''' ''' da_files = [ "../tone_stim/stimulus/tone_2000/tone_3000_2000Hz.wav", "../tone_stim/stimulus/tone_500/tone_3000_500Hz.wav" ] story_dir = "../eeg_story_stim/stimulus" mat_dir = "../matrix_test/speech_components" noise_file = "../matrix_test/behavioural_stim/stimulus/wav/noise/noise_norm.wav" da_noise_file = "../da_stim/noise/wav/noise/noise_norm.wav" story_wavs = globDir(story_dir, '*.wav') mat_wavs = globDir(mat_dir, '*.wav') out_dir = "./out" out_red_dir = os.path.join(out_dir, 'reduction_coefficients') out_stim_dir = os.path.join(out_dir, 'stimulus') dir_must_exist(out_dir) dir_must_exist(out_red_dir) dir_must_exist(out_stim_dir) story_coef = calc_potential_max(story_wavs, noise_file, out_red_dir, "story_red_coef") mat_coef = calc_potential_max(mat_wavs, noise_file, out_red_dir, "mat_red_coef") da_coef = calc_potential_max(da_files, da_noise_file, out_red_dir, "da_red_coef") mat_cal_stim = "../matrix_test/long_concat_stim/out/stim/stim_0.wav" da_cal_stim = "./out/stimulus/1k_tone.wav" # click_cal_stim = "../tone_stim/stimulus/tone_2000/tone_3000_2000Hz.wav" story_cal_stim = "../eeg_story_stim/stimulus/odin_1_1.wav" mat_out_stim = os.path.join(out_stim_dir, "mat_cal_stim.wav") # click_out_stim = os.path.join(out_stim_dir, "click_cal_stim.wav") da_out_stim = os.path.join(out_stim_dir, "1k_cal_stim.wav") story_out_stim = os.path.join(out_stim_dir, "story_cal_stim.wav") block_process_wav(mat_cal_stim, mat_out_stim, lambda x: x * mat_coef) block_process_wav(story_cal_stim, story_out_stim, lambda x: x * story_coef) block_process_wav(da_cal_stim, da_out_stim, lambda x: x * da_coef)
def main(): ''' ''' dir_must_exist('./stimulus') gen_da_stim(1500, './stimulus/3000_da.wav')
def loadStimulus(self): ''' ''' self.participant.load('mat_test') try: srt_50=self.participant.data['mat_test']['srt_50'] s_50=self.participant.data['mat_test']['s_50'] except KeyError: raise KeyError("Behavioural matrix test results not available, make " "sure the behavioural test has been run before " "running this test.") #reduction_coef = float(np.load(os.path.join(self.listDir, 'reduction_coef.npy'))) # Calculate SNRs based on behavioural measures s_50 *= 0.01 shuffle(self.si) x = logit(self.si * 0.01) snrs = (x/(4*s_50))+srt_50 self.snr_fs = 10**(-snrs/20) self.snr_fs = np.append(self.snr_fs, np.inf) self.si = np.append(self.si, np.inf) snrs = np.append(snrs, np.inf) self.snr_fs[self.snr_fs == np.inf] = 0. if (self.snr_fs == -np.inf).any(): raise ValueError("Noise infinitely louder than signal for an SNR (SNRs: {})".format(self.snr_fs)) wavs = globDir(self.stim_folder, "*.wav") questions = globDir(self.stim_folder, "stim_questions_*.csv") if not len(questions): raise FileNotFoundError("No question files found in {}".format(self.stim_dir)) rms_files = globDir(self.stim_folder, "stim_*_rms.npy") if not len(rms_files): raise FileNotFoundError("No rms files found in {}".format(self.stim_dir)) self.socketio.emit('test_stim_load', namespace='/main') # Add noise to audio files at set SNRs and write to participant # directory self.data_path = self.participant.data_paths[self.test_name] out_dir = os.path.join(self.data_path, "stimulus") out_info = os.path.join(out_dir, "stim_info.csv") dir_must_exist(out_dir) with open(out_info, 'w') as csvfile: writer = csv.writer(csvfile) writer.writerow(['wav', 'snr_fs', 'rms', 'si', 'snr']) for wav, snr_fs, rms, si, snr in zip(wavs, self.snr_fs, rms_files, self.si, snrs): out_wavpath = os.path.join(out_dir, os.path.basename(wav)) stim_rms = np.load(rms) match_ratio = stim_rms/self.noise_rms block_mix_wavs(wav, self.noise_path, out_wavpath, 1.*self.reduction_coef, snr_fs*match_ratio*self.reduction_coef) self.stim_paths.append(out_wavpath) writer.writerow([wav, snr_fs, rms, si, snr]) # TODO: Output SI/snrs of each file to a CSV file for q_file_path in questions: q = [] with open(q_file_path, 'r') as q_file: q_reader = csv.reader(q_file) for line in q_reader: q.append(line) self.question.append(q) self.answers = np.empty(np.shape(self.question)[:2]) self.answers[:] = np.nan
type=PathType(exists=None, type='dir'), default='./stimulus', help='Output directory') parser.add_argument('--CalcRMS', action='store_true') args = { k: v for k, v in vars(parser.parse_args()).items() if v is not None } rmsDir = os.path.join(args['OutDir'], "rms") if args['CalcRMS']: indexes = gen_indexes() wavFiles = gen_audio_stim(args['MatrixDir'], args['OutDir'], indexes) rmsFiles = gen_rms(wavFiles, rmsDir) else: wavDir = os.path.join(args['OutDir'], "wav") dir_must_exist(wavDir) wavFiles = globDir(wavDir, '*.wav') wf = [] for listInd in range(50): wf.append([]) for sentenceInd in range(10): wf[listInd].append(wavFiles[listInd * 10 + sentenceInd]) wavFiles = wf rmsFiles = globDir(rmsDir, 'Trial*.npy') silences = detect_silences(rmsFiles, 44100) s_rms = calc_speech_rms(wavFiles, silences, rmsDir) b = calc_spectrum(wavFiles, silences) y = gen_noise(args['OutDir'], b, 44100)
def main(): stim_dir = "../behavioural_stim/stimulus" wav_dir = "../behavioural_stim/stimulus/wav" base_dir = "../behavioural_stim/stimulus/wav/sentence-lists/" noise_dir = "../behavioural_stim/stimulus/wav/noise/" out_dir = "./out" dir_must_exist(base_dir) dir_must_exist(out_dir) dir_must_exist(wav_dir) dir_must_exist(noise_dir) noise_filepath = "../behavioural_stim/stimulus/wav/noise/noise_norm.wav" folders = os.listdir(base_dir) folders = natsorted(folders)[1:15] folders = list(zip(folders[::2], folders[1::2])) calc_potential_max(base_dir, noise_filepath, out_dir) n_questions = 4 fs = 44100 for ind, (list_folder_1, list_folder_2) in enumerate(folders): out_folder_name = 'Stim_{}'.format(ind) out_folder = os.path.join(out_dir, out_folder_name) delete_if_exists(out_folder) dir_must_exist(out_folder) out_wav_path = os.path.join(out_folder, "stim.wav") out_csv_path = os.path.join(out_folder, "markers.csv") out_rms_path = os.path.join(out_folder, "rms.npy") out_q_path = [ os.path.join(out_folder, "questions_{}.csv".format(x)) for x in range(n_questions) ] out_wav = PySndfile(out_wav_path, 'w', construct_format('wav', 'pcm16'), 3, 44100) list_1_wav = globDir(os.path.join(base_dir, list_folder_1), '*.wav') list_2_wav = globDir(os.path.join(base_dir, list_folder_2), '*.wav') list_1_csv = globDir(os.path.join(base_dir, list_folder_1), '*.csv') list_2_csv = globDir(os.path.join(base_dir, list_folder_2), '*.csv') merged_wavs = list_1_wav + list_2_wav merged_csvs = list_1_csv + list_2_csv words = [] for c in merged_csvs: with open(c, 'r') as csvfile: for line in csv.reader(csvfile): words.append(line) c = list(zip(merged_wavs, words)) shuffle(c) merged_wavs, words = zip(*c) sum_sqrd = 0. n = 0 with open(out_csv_path, 'w') as csvfile, ExitStack() as stack: # Open all question files qfiles = [ stack.enter_context(open(qfile, 'w')) for qfile in out_q_path ] writer = csv.writer(csvfile) qwriters = [csv.writer(qfile) for qfile in qfiles] counter = 0 stim_count = len(merged_wavs) stim_count_half = stim_count // 2 q_inds = np.array([ sample(range(0, stim_count_half), n_questions), sample(range(stim_count_half, stim_count - 1), n_questions) ]).T a = 0 silence = np.zeros((88200, 3)) idx = np.arange(0, silence.shape[0]) trigger = gen_trigger(idx, 2., 0.01, fs) silence[:, 2] = trigger out_wav.write_frames(silence) for ind, (wav, txt) in enumerate(zip(merged_wavs, words)): csv_line = [counter] silence = np.zeros((int( np.random.uniform(int(0.3 * 44100), int(0.4 * 44100), 1)), 3)) idx = np.arange(counter, counter + silence.shape[0]) trigger = gen_trigger(idx, 2., 0.01, fs) silence[:, 2] = trigger out_wav.write_frames(silence) counter += silence.shape[0] csv_line.append(counter) csv_line.append("#") writer.writerow(csv_line) csv_line = [counter] x, fs, enc = sndio.read(wav) sum_sqrd += np.sum(x**2) n += x.size y = np.vstack([x, x, np.zeros(x.size)]).T idx = np.arange(counter, counter + y.shape[0]) trigger = gen_trigger(idx, 2., 0.01, fs) y[:, 2] = trigger out_wav.write_frames(y) counter += y.shape[0] csv_line.append(counter) csv_line.append(" ".join(txt)) writer.writerow(csv_line) if ind in q_inds: writer_ind = int(np.where(ind == q_inds)[0]) blank_ind = randint(0, len(txt) - 1) q_list = copy(txt) q_list[blank_ind] = '_' qwriters[writer_ind].writerow( [" ".join(q_list), txt[blank_ind]]) a += 1 if a != 8: pdb.set_trace() csv_line = [counter] silence = np.zeros( (int(np.random.uniform(int(0.3 * 44100), int(0.4 * 44100), 1)), 3)) idx = np.arange(counter, counter + silence.shape[0]) trigger = gen_trigger(idx, 2., 0.01, fs) silence[:, 2] = trigger out_wav.write_frames(silence) counter += silence.size csv_line.append(counter) csv_line.append("#") writer.writerow(csv_line) rms = np.sqrt(sum_sqrd / n) np.save(out_rms_path, rms) x, fs, enc = sndio.read(out_wav_path)
type=PathType(exists=True, type='dir'), default='../speech_components', help='Matrix test speech data location') parser.add_argument('--OutDir', type=PathType(exists=None, type='dir'), default='./out', help='Output directory') parser.add_argument('--Length', type=int, default=3600, help='Concatenated length of trials in seconds') args = { k: v for k, v in vars(parser.parse_args()).items() if v is not None } dir_must_exist(args['OutDir']) # Check directory for storing generated noise exists #noiseDir = os.path.join(args['OutDir'], 'noise') #dir_must_exist(noiseDir) #decoderDir = os.path.join(args['OutDir'], 'decoder') #dir_must_exist(noiseDir) ##generateDecoderAudio(args['OutDir'], noiseDir, decoderDir) #pdb.set_trace() #if os.path.exists(args['OutDir']): # shutil.rmtree(args['OutDir']) # os.makedirs(args['OutDir']) # Generate output directory if it doesn't exist outDir = args.pop("OutDir") prepareOutDir(outDir)
def loadStimulus(self): ''' ''' self.participant.load('mat_test') try: srt_50 = self.participant.data['mat_test']['srt_50'] s_50 = self.participant.data['mat_test']['s_50'] except KeyError: raise KeyError( "Behavioural matrix test results not available, make " "sure the behavioural test has been run before " "running this test.") #reduction_coef = float(np.load(os.path.join(self.listDir, 'reduction_coef.npy'))) # Calculate SNRs based on behavioural measures ''' s_50 *= 0.01 shuffle(self.si) x = logit(self.si * 0.01) snrs = (x/(4*s_50))+srt_50 snrs = np.append(snrs, np.inf) snrs = np.append(snrs, 10.0) self.si = np.append(self.si, np.inf) self.si = np.append(self.si, 10.0) self.snr_fs = 10**(-snrs/20) self.snr_fs[self.snr_fs == np.inf] = 0. if (self.snr_fs == -np.inf).any(): raise ValueError("Noise infinitely louder than signal for an SNR (SNRs: {})".format(self.snr_fs)) ''' snrs = np.squeeze(self.participant.data['parameters']['tone_SNRs']) snrs[~np.isinf(snrs)] += srt_50 self.snr_fs = 10**(-snrs / 20) self.snr_fs[self.snr_fs == np.inf] = 0. if (self.snr_fs == -np.inf).any(): raise ValueError( "Noise infinitely louder than signal for an SNR (SNRs: {})". format(self.snr_fs)) self.data_path = self.participant.data_paths[self.test_name] out_dir = os.path.join(self.data_path, "stimulus") delete_if_exists(out_dir) out_info = os.path.join(out_dir, "stim_info.csv") dir_must_exist(out_dir) stim_dirs = [ x for x in os.listdir(self.stim_folder) if os.path.isdir(os.path.join(self.stim_folder, x)) ] ordered_stim_dirs = [] for freq in self.participant_parameters['tone_freqs']: for folder in stim_dirs: if re.match(f'tone_({int(freq)})', folder): ordered_stim_dirs.append(folder) ordered_stim_dirs *= int(len(snrs)) for ind, dir_name in enumerate(ordered_stim_dirs): stim_dir = os.path.join(self.stim_folder, dir_name) wavs = globDir(stim_dir, "*.wav") intensity_files = globDir(stim_dir, "*intensity.npy") self.socketio.emit('test_stim_load', namespace='/main') # Add noise to audio files at set SNRs and write to participant # directory with open(out_info, 'w') as csvfile: writer = csv.writer(csvfile) writer.writerow(['wav', 'snr_fs', 'intensity', 'snr']) for wav, snr_fs, intensity, snr in zip(wavs, self.snr_fs, intensity_files, snrs): fp = os.path.splitext( os.path.basename(wav))[0] + "_{}.wav".format(snr) out_wavpath = os.path.join(out_dir, fp) stim_intensity = np.load(intensity) match_ratio = stim_intensity / self.noise_intensity block_mix_wavs(wav, self.noise_path, out_wavpath, self.reduction_coef, snr_fs * match_ratio * self.reduction_coef, mute_left=False) self.stim_paths.extend([out_wavpath]) writer.writerow([wav, snr_fs, intensity, snr])
# Create commandline interface parser = argparse.ArgumentParser(description='Generate stimulus for ' 'training TRF decoder by concatenating ' 'matrix test materials') parser.add_argument('--OutDir', type=PathType(exists=None, type='dir'), default='./noise', help='Output directory') parser.add_argument('--CalcRMS', action='store_true') args = { k: v for k, v in vars(parser.parse_args()).items() if v is not None } rmsDir = os.path.join(args['OutDir'], "rms") dir_must_exist(rmsDir) peakDir = os.path.join(args['OutDir'], "peak") dir_must_exist(peakDir) wavDir = os.path.join(args['OutDir'], "wav") dir_must_exist(wavDir) if args['CalcRMS']: daFile = globDir('./noise_source', 'male_speech_resamp.wav')[0] rmsFiles, peakFiles = gen_rms_peak([daFile], rmsDir, peakDir) rmsFile = rmsFiles[0] peakFile = peakFiles[0] else: daFile = globDir('./noise_source', 'male_speech_resamp.wav')[0] rmsFile = globDir(rmsDir, '*.npy')[0] peakFile = globDir(peakDir, '*.npy')[0] #silences = detect_silences([rmsFile], 44100, None) s_rms = calc_speech_rms(['./stimulus/3000_da.wav'], [[]], rmsDir)