tr_attn = tr_attn[trial_order] tr_targs = tr_targs[trial_order] tr_foils = tr_foils[trial_order] tr_targ_loc = tr_targ_loc[trial_order] tr_foil_loc = tr_foil_loc[trial_order] tr_onsets = tr_onsets[trial_order] tr_onset_samp = tr_onset_samp[trial_order] tr_stim = tr_stim[trial_order] # WRITE WAV FILES if write_wavs: print('Writing stimuli to disk') for tnum, trial in enumerate(tr_stim): fname = 'trial-{}-{}.wav'.format(np.char.mod('%03d', tnum), ''.join(np.char.array(tr_attn[tnum]))) stim.write_wav(op.join(stimdir, fname), trial, output_fs, overwrite=True) # training stims for tnum, trial in enumerate(one_stim): fname = 'train-one-{}.wav'.format(np.char.mod('%02d', tnum)) stim.write_wav(op.join(stimdir, fname), trial, output_fs, overwrite=True) for tnum, trial in enumerate(two_stim): fname = 'train-two-ab-{}.wav'.format(np.char.mod('%02d', tnum)) stim.write_wav(op.join(stimdir, fname), trial, output_fs, overwrite=True) for tnum, trial in enumerate(four_a_stim): fname = 'train-four-a-{}.wav'.format(np.char.mod('%02d', tnum)) stim.write_wav(op.join(stimdir, fname), trial, output_fs, overwrite=True) for tnum, trial in enumerate(four_aa_stim): fname = 'train-four-aa-{}.wav'.format(np.char.mod('%02d', tnum))
def test_read_write_wav(): """Test reading and writing WAV files """ fname = op.join(tempdir, 'temp.wav') data = np.r_[np.random.rand(1000), 1, -1] fs = 44100 # Use normal 16-bit precision: not great write_wav(fname, data, fs) data_read, fs_read = read_wav(fname) assert_equal(fs_read, fs) assert_array_almost_equal(data[np.newaxis, :], data_read, 4) # test our overwrite check assert_raises(IOError, write_wav, fname, data, fs) # test forcing fs dtype to int with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') write_wav(fname, data, float(fs), overwrite=True) assert_equal(len(w), 1) # Use 64-bit int: not supported assert_raises(RuntimeError, write_wav, fname, data, fs, dtype=np.int64, overwrite=True) # Use 32-bit int: better write_wav(fname, data, fs, dtype=np.int32, overwrite=True) data_read, fs_read = read_wav(fname) assert_equal(fs_read, fs) assert_array_almost_equal(data[np.newaxis, :], data_read, 7) if _has_scipy_version('0.13'): # Use 32-bit float: better write_wav(fname, data, fs, dtype=np.float32, overwrite=True) data_read, fs_read = read_wav(fname) assert_equal(fs_read, fs) assert_array_almost_equal(data[np.newaxis, :], data_read, 7) # Use 64-bit float: perfect write_wav(fname, data, fs, dtype=np.float64, overwrite=True) data_read, fs_read = read_wav(fname) assert_equal(fs_read, fs) assert_array_equal(data[np.newaxis, :], data_read) else: assert_raises(RuntimeError, write_wav, fname, data, fs, dtype=np.float32, overwrite=True) # Now try multi-dimensional data data = np.tile(data[np.newaxis, :], (2, 1)) write_wav(fname, data[np.newaxis, :], fs, overwrite=True) data_read, fs_read = read_wav(fname) assert_equal(fs_read, fs) assert_array_almost_equal(data, data_read, 4) # Make sure our bound check works assert_raises(ValueError, write_wav, fname, data * 2, fs, overwrite=True)
n_talkers = len(talkers[0][0]) # For each talker make a string for ri, r in enumerate(regions): # Make pairs out of each region for ti in range(n_talkers): # pairs should be gender-paired order = rand.permutation(n_sent) string = np.zeros((2, 0)) save_fn = '' for si in order: s = sentences[si] wavs = [] for gi, g in enumerate(genders): t = talkers[ri][gi][ti] fn = file_str % (r, g, t, s) w, fs = stim.read_wav(fn, verbose=False) wavs += [w] if si == order[0]: save_fn += '%s%s%s_' % (r, g, t) lens = np.array([w.shape[-1] for w in wavs]) len_max = lens.max() shifts = ((len_max - lens) / 2.).astype(int) string = np.concatenate((string, np.zeros((2, len_max))), -1) string_len = string.shape[-1] for gi, start_ind in enumerate(shifts - len_max + string_len): string[gi, start_ind:start_ind + lens[gi]] = wavs[gi] save_fn = save_fn[:-1] + '.wav' save_fn = r + str(ti) + '.wav' stim.write_wav(os.path.join(save_path, save_fn), string, fs, overwrite=True) print('Finished talker %i / %i.' % (ti + 1, n_talkers))
del list_names datas = list() print('Reading and resampling stimuli...') for ii, (name, code) in enumerate(zip(names, codes)): data, fs_read = read_wav(op.join(stim_dir, name), verbose=False) assert fs == fs_read assert (data[0] == data[1]).all() data = data[0] # one channel datas.append(resample(data, fs_out, fs, npad='auto')) assert np.isclose(datas[-1].shape[-1] / float(fs_out), data.shape[-1] / float(fs), atol=1e-3) # 1 ms assert len(datas) == len(names) rmss = [rms(d) for d in datas] factor = rms_out / np.mean(rmss) print('Writing stimuli...') for name, data in zip(names, datas): data *= factor # RMS mean across stimuli is now our desired value write_wav(op.join(out_dir, name), data, fs_out, verbose=False, overwrite=True) rmss = np.array([rms(d) for d in datas]) assert np.isclose(np.mean(rmss), rms_out) play_rmss = dB_out + 20 * np.log10(rmss / rms_out) print('Assuming a %s dB SPL set in ExperimentController, stimuli will ' 'play with a long-term RMS of:\n[%0.1f, %0.1f] dB' % (dB_out, play_rmss.min(), play_rmss.max()))
taud_stim = [] nocomp_stim_name = [] control_stim = [] for trial in range(n_tpc): for cc in range(n_cond): for config, xc in enumerate(space_conditions): if config == 0: print -30.0, 0.0 onetone1_twonoise2 = np.nansum([one_1e_tone, two_2_noise], axis=0) fname = ('onetone1_twonoise2_%s_%s_%s.wav' % (config, cc, trial)) taud_stim.append(fname) stim.write_wav(fname, onetone1_twonoise2, fs, overwrite=True, verbose=False) # control if trial <= 4: c_onetone1_twonoise2 = onetone1_twonoise2 fname = ('c_onetone1_twonoise2_%s_%s_%s.wav' % (config, cc, trial)) control_stim.append(fname) stim.write_wav(fname, c_onetone1_twonoise2, fs, overwrite=True, verbose=False) onenoise1_twotone2 = np.nansum([one_1e_noise, two_2_tone], axis=0) fname = ('onenoise1_twotone2_%s_%s_%s.wav' % (config, cc, trial)) taud_stim.append(fname) stim.write_wav(fname, onenoise1_twotone2, fs,
names, codes, isis = parse_list(op.join(stim_dir, list_names[0])) names_b, codes_b, isis_b = parse_list(op.join(stim_dir, list_names[1])) assert set(names) == set(names_b) list_name = list_names[0] # okay, just process one then del list_names datas = list() print('Reading and resampling stimuli...') for ii, (name, code) in enumerate(zip(names, codes)): data, fs_read = read_wav(op.join(stim_dir, name), verbose=False) assert fs == fs_read assert (data[0] == data[1]).all() data = data[0] # one channel datas.append(resample(data, fs_out, fs, npad='auto')) assert np.isclose(datas[-1].shape[-1] / float(fs_out), data.shape[-1] / float(fs), atol=1e-3) # 1 ms assert len(datas) == len(names) rmss = [rms(d) for d in datas] factor = rms_out / np.mean(rmss) print('Writing stimuli...') for name, data in zip(names, datas): data *= factor # RMS mean across stimuli is now our desired value write_wav(op.join(out_dir, name), data, fs_out, verbose=False, overwrite=True) rmss = np.array([rms(d) for d in datas]) assert np.isclose(np.mean(rmss), rms_out) play_rmss = dB_out + 20 * np.log10(rmss / rms_out) print('Assuming a %s dB SPL set in ExperimentController, stimuli will ' 'play with a long-term RMS of:\n[%0.1f, %0.1f] dB' % (dB_out, play_rmss.min(), play_rmss.max()))
# -*- coding: utf-8 -*- """ ============================= Script 'DAS-cog-load stimuli' ============================= This script makes spatially-distributed word streams. """ # Author: Dan McCloy <*****@*****.**> # # License: BSD (3-clause) import os.path as op from glob import glob from expyfun.stimuli import rms, read_wav, write_wav indir = 'monotonizedWords' outdir = 'normalizedWords' target_rms = 0.01 files = glob(op.join(indir, '*.wav')) for f in files: fname = op.split(f)[-1] wav, fs = read_wav(f) new_wav = wav * target_rms / rms(wav) write_wav(op.join(outdir, fname), new_wav, fs)
regions = ['NW', 'CH'] talkers = [str(i) for i in range(5)] loc = ['C', 'S'] az = [0, -60] n_talkers = 3 wavs = [[np.zeros((2, 0)) for _ in range(2)] for _ in range(2)] for ti, t in enumerate(talkers[:n_talkers]): #for ri, r in enumerate(regions): ri = 0 r = regions[ri] wav, fs = stim.read_wav(join(opath, r + t + '.wav')) for gi, g in enumerate(genders): for li, (l, a) in enumerate(zip(loc, az)): wav_loc = stim.convolve_hrtf(wav[gi], fs, a) lens = [wavs[gi][li].shape[-1], wav_loc.shape[-1]] dl = lens[0] - lens[1] if dl < 0: wavs[gi][li] = np.concatenate((wavs[gi][li], np.zeros((2, -dl))), -1) if dl > 0: wav_loc = np.concatenate((wav_loc, np.zeros((2, dl))), -1) wavs[gi][li] += wav_loc for gi, g in enumerate(genders): for li, (l, a) in enumerate(zip(loc, az)): fn = join(spath, '%s_%s_%s.wav' % (r, g, l)) data = wavs[gi][li] / np.sqrt(n_talkers) data = np.minimum(1, np.maximum(-1, data)) stim.write_wav(fn, data, fs, overwrite=True)