def play(wav, fs=44100): """ play(wav, fs=44100) Play WAV at sampling rate FS. """ audiolab.play(wav.T, fs)
def __play_character(self, character): """Play a character through the audio device :param character: (str) Character to be played :raise TypeError: If a single character is not passed """ play(character)
def read_wav(self, sample_path): sample = Sndfile(cwd + sample_path, 'r') sampling_rate = sample.samplerate channels = sample.channels encoding = sample.encoding frames_count = sample.nframes frames = sample.read_frames(frames_count, dtype=np.float32) sample.close() del sample if channels == 1: text_type = 'mono' sample_type = 0 elif channels == 2: text_type = 'stereo' sample_type = 0b01100100 else: text_type = '{0}-channels'.format(channels) if OPTIONS['verbose'] > 1: print "*", encoding, text_type, 'sample "', sample_path, '"', 4 * frames_count, 'kB' if OPTIONS['play_sound']: play(frames.astype(np.float64).T, sampling_rate) self.update({ 'sample_data': frames, 'sample_type': sample_type, 'channels': 2, 'sample_bittype': 4 })
def playTone(self, freq): t = np.arange(0, 0.5, 1./self.fs) s = np.sin(2*np.pi*freq*t) s_ramp = self._ramped(s, self.fs) al.play(s_ramp, self.fs)
def on_pick(event): try: i = artists.index(event.artist) print i play(pieces[i]) except: return True return True
def play(self): if have_sk_audiolab and have_sk_samplerate: play( np.array(resample(self.data, 44100. / self.fs, 'sinc_best'), dtype=np.float64)) else: print( 'Warning: scikits.audiolab and scikits.samplerate are required to play audiofiles.' )
def main(): x, fs, nbits = audiolab.wavread(argv[0]) audiolab.play(x, fs) N = 38*fs # four seconds of audio X = scipy.fft(x[:N]) Xdb = 20*scipy.log10(scipy.absolute(X)) f = scipy.linspace(0, fs, N, endpoint=False) pylab.plot(f, Xdb) pylab.xlim(0, 48000) # view up to 5 kHz Y = X*H y = scipy.real(scipy.ifft(Y))
def play_sin_beep(secs = DEFAULT_SECONDS, notefreq = DEFAULT_FREQUENCY, delay = DEFAULT_DELAY): # define the length of the beep fs = 44100 vectorstep = 1/float(fs) # create the sinusoidal vector sin_vect = sin([2 * pi * notefreq * x for x in arange(0, secs, vectorstep)]) normalization_const = max(sin_vect) beep = array([x/normalization_const for x in sin_vect]) a.play(beep, fs=fs) time.sleep(delay)
def generate(): ccipca = CCIPCAProcessor((8193, 200), plot=False) ccipca.output_ccipca = CCIPCA(divisi2.load('chess.eigs')) pipe = ronwtools.Pipeline( ronwtools.AudioSource('../koyaanisqatsi.ogg'), ronwtools.Mono(), ronwtools.STFT(nfft=16384, nhop=4096, winfun=np.hanning), ccipca, ronwtools.ISTFT(nfft=16384, nhop=4096, winfun=np.hanning), ronwtools.Framer(1048576) ) for segment in pipe: print np.max(segment) segment /= np.max(segment) audiolab.play(segment)
def learnit(): ccipca = CCIPCAProcessor((8193, 400), plot=False, amnesia=1.0) pipe = ronwtools.Pipeline( ronwtools.AudioSource('../chess.ogg'), ronwtools.Mono(), ronwtools.STFT(nfft=16384, nhop=4096, winfun=np.hanning), ccipca, ronwtools.ISTFT(nfft=16384, nhop=4096, winfun=np.hanning), ronwtools.Framer(524288) ) for segment in pipe: segment /= np.max(segment) print np.max(segment) audiolab.play(segment) divisi2.save(ccipca.ccipca.matrix, 'chess2.eigs')
def audio_test(): aud = Audio.objects.first() print 'Frames: %i' % aud.frames print 'Encoding: %s' % aud.encoding print 'Rate: %i' % aud.rate print 'Channels: %i' % aud.ch print 'Speaker: %s' % Speaker.objects.with_id(aud.speaker).name print 'Filename: %s' % aud.filename print 'Speaker Name: %s' % aud.speaker_name fname_out = self_extract(aud.data, aud.filename + '.' + aud.encoding) sfile = audio.Sndfile(fname_out, 'r') sndvec = sfile.read_frames(aud.frames) audio.play(sndvec, aud.rate)
def al_play(snd, fs): import scikits.audiolab as al import numpy as np from scipy.signal import resample if len(snd.shape) == 2: if snd.shape[1] == 2 or snd.shape[1] == 1: snd = snd.T elif snd.shape[0] != 2 and snd.shape[0] != 1: print "sound must either a vector or a rank 2 matrix" return N = snd.shape[1] else: N = snd.shape[0] snd = snd.reshape(-1, N) rsmple = resample(snd, N * 44100.0 / (1.0 * fs), axis=1) al.play(rsmple, fs=44100)
def audio_test(): aud = Audio.objects.first() print 'Frames: %i' % aud.frames print 'Encoding: %s' % aud.encoding print 'Rate: %i' % aud.rate print 'Channels: %i' % aud.ch print 'Speaker: %s' % Speaker.objects.with_id(aud.speaker).name print 'Filename: %s' % aud.filename print 'Speaker Name: %s' % aud.speaker_name fname_out = self_extract(aud.data, aud.filename+'.'+aud.encoding) sfile = audio.Sndfile(fname_out, 'r') sndvec = sfile.read_frames(aud.frames) audio.play(sndvec, aud.rate)
def PlayKosAlertSound(self): global winsound if winsound: try: winsound.PlaySound("SystemQuestion", winsound.SND_ALIAS) except: # such as when there's no SystemQuestion sound, reported by some users. winsound = False elif play and options.sound_file: data = None if options.sound_file.endswith("ogg"): data, fs, _ = oggread(options.sound_file) elif options.sound_file.endswith("wav"): data, fs, _ = wavread(options.sound_file) if data is not None: play(data.T, fs)
def correlate(): ccipca = CCIPCAProcessor((8193, 200), plot=False, amnesia=1.0) ccipca.ccipca = CCIPCA(divisi2.load('chess.eigs')) ccipca.ccipca.iteration = 100000 ccipca.output_ccipca = ccipca.ccipca pipe = ronwtools.Pipeline( ronwtools.AudioSource('../chess.ogg'), ronwtools.Mono(), ronwtools.STFT(nfft=16384, nhop=4096, winfun=np.hanning), ccipca, ronwtools.ISTFT(nfft=16384, nhop=4096, winfun=np.hanning), ronwtools.Framer(1048576) ) for segment in pipe: print np.max(segment) segment /= np.max(segment) audiolab.play(segment)
def play_rand(file, name): sound = audiolab.sndfile(file) limit = sound.get_nframes() frames = sound.read_frames(sound.get_nframes()) * 0.8 if limit < size: return for i in range(5): start = random.randint(0, limit - size) print("Is this a voice? [(y)es, (n)o, " + "(s)kip/significant-portions-of-both/can't-tell, (r)eplay]") audiolab.play(frames[start:start + size][:, 0]) while True: input = raw_input() if input == "r": audiolab.play(frames[start:start + size][:, 0]) elif input in ["y", "n", "s"]: break print >> outfile, name, start, start + size, input
def play_rand(file, name): sound = audiolab.sndfile(file) limit = sound.get_nframes() frames = sound.read_frames(sound.get_nframes()) * 0.8 if limit < size: return for i in range(5): start = random.randint(0, limit - size) print("Is this a voice? [(y)es, (n)o, " + "(s)kip/significant-portions-of-both/can't-tell, (r)eplay]") audiolab.play(frames[start: start + size][:,0]) while True: input = raw_input() if input == "r": audiolab.play(frames[start: start + size][:,0]) elif input in ["y", "n", "s"]: break print >> outfile, name, start, start + size, input
def play(self,start="0m0s",end="0m0s"): sm = ss = m = s = 0 if 'm' in start: sm = int(start[:start.find('m')]) if 'm' in end: m = int(end[:end.find('m')]) if 's' in end: s = int(end[end.find('m')+1:end.find('s')]) if 's' in start: ss = int(start[start.find('m')+1:start.find('s')]) frames = (m*60+s)*self.freq sf = (sm*60+ss)*self.freq if frames>self.frames or frames==0: frames = self.frames if sf > self.frames: sf = 0 aulab.play(self.data[sf:frames],fs=self.freq)
def test_callback(samples, rtlsdr_obj): #print(samples) mpl.clf() #dataset.extend(samples) x = samples yb1 = signal.convolve(x, filterB1) #mpl.psd(yb1, NFFT=1024, Fc=0, Fs=48e3) yn1 = downsample(yb1, 10) #mpl.psd(yn1, NFFT=1024, Fc=0, Fs=sdr.rs/10) zdis = discrim(yn1) #mpl.psd(zdis, NFFT=1024, Fc=0, Fs=sdr.rs/10) zb2 = signal.convolve(zdis, filterB2) zn2 = downsample(zb2, 5) mpl.psd(x) mpl.psd(zn2, NFFT=1024, Fc=0, Fs=48e3) mpl.plot(zdis) mpl.pause(0.0001) mpl.show(block=False) zn2 /= npmax(abs(zn2),axis=0) # complex2wav("teste.wav",48e3,zn2) play(zn2, fs=48e3)
from scikits.audiolab import play, wavread data, fs, enc = wavread('test.wav') # There is a discrepency between wavread (one column per channel) and play # convention (one row per channel). Audiolab will be fully converted to 'numpy # conventions' (last axis per default) after version 0.9 play(data.T, fs)
def _play(self,start=0,frames=0): if frames == 0: frames = self.frames aulab.play(self.data[start:frames],fs=self.freq)
def playwave(f, tf=1, timber=harmonic): """plays sine wave with frequency f and duration tf""" t = time_arr(tf, fs) y = timber(f, t) al.play(y, fs=fs)
def start_music(conn, play_args): conn.send(None) conn.close() audiolab.play(*play_args)
# Encoding with matching pursuit X = np.zeros((Y.shape[0], D_multi.shape[0])) for idx in range(Y.shape[0]): X[idx, :] = matching_pursuit(Y[idx, :], D_multi) # Reconstruction of the signal out = np.zeros(int((np.ceil(len(y) / resolution) + 1) * resolution)) for k in range(0, len(X)): idx = range(k * (resolution - overlap), k * (resolution - overlap) + resolution) out[idx] += np.dot(X[k], D_multi) squared_error = np.sum((y - out[0:len(y)])**2) # Play the original signal and the reconstructed for comparison play(y, fs=16000) play(out, fs=16000) # Plotting results # 1st plot: original signal/reconstructed signal/residuals arr = np.array(range(length_sound)) / float(fs) plt.figure(1) plt.subplot(311) plt.plot(arr, y, 'b', label="Input Signal") plt.legend() plt.subplot(312) plt.plot(arr, out[0:len(y)], 'r', label="Recontruction") plt.legend() plt.subplot(313) plt.plot(arr, (y - out[0:len(y)])**2, 'g', label="Residual")
import numpy as np from scikits.audiolab import play # output one second of stereo gaussian white noise at 48000 hz play(0.05 * np.random.randn(2, 48000))
def play(self, norm=True): if norm: samples = normrange(self.samples) else: samples = self.samples AL.play(samples, self.samplerate)
def play(self): play(self.signal, fs=self.samplerate)
y,fstmp,fmt = audiolab.wavread('glockenspiel.wav') #y = np.sum(y,1)/y.shape[1] # make mono y = samplerate.resample(y, fs/fstmp,'sinc_best') # resample for faster computation # setup scales = [256,512,1024,2048, 4096] # window sizes to use L = np.ceil(len(y)/float(np.max(scales)))*np.max(scales) # calc block boundary y = np.hstack((y,np.zeros(L-len(y)))) # pad input to block boundary # Build multi-scale Gabor dictionary D = DictionaryUnion(*[GaborBlock(L,s) for s in scales]) # Analysis (basis pursuit denoising: min ||x||_1 s.t. ||y-Dx||_2<e) x = BPDN(D,y,maxerr=1e-12,maxits=1000) # Plots parts = D.parts(x) for i,p in enumerate(parts): pylab.figure() freqsup = range(0,D[i].fftLen/2+1) pylab.imshow(20*np.log10(np.abs(p[:,freqsup].transpose())), aspect='auto', interpolation='bilinear', origin='lower') # Sounds synth = [np.array(samplerate.resample(np.real(D[i].dot(p)), fstmp/fs, 'sinc_best'), dtype='float64') for i,p in enumerate(parts)] for s in synth: audiolab.play(s) pylab.show()
def play_audio(): for dtype, inverted_vocab in get_inverse_vocabs().iteritems(): if dtype != TIMBRE_GROUP: continue for i, vec in enumerate(inverted_vocab): play(gen_timbre(vec))
# extract and print the number of channels nc = f.channels print "number of channels: ", nc # extract and print the encoding format enc = f.encoding print "encoding format: ", enc # extract the number of frames - single samples for # mono and pairs of samples for stereo num_samples = f.nframes ################################################# ######## READ AUDIO SAMPLES FROM THE FILE ####### ################################################# # we can read audio samples using the read_frame method samples = f.read_frames(num_samples) ################################################# ############# PLAYING AN AUDIO FILE ############# ################################################# # play the audio file data in 'samples' at the sampling frequency 'fs' play(samples, fs) ################################################# ################################################# #################################################
def play(self): audiolab.play(self.signal.T)
#wname = mktemp('.wav') #print(wname) #check_call(['avconv', '-i', flacfile, wname]) #sig, fs, enc = flacread(wname) sig, fs, enc = flacread(flacfile) #os.unlink(wname) # bandpass filter bands = np.array([0, 3500, 4000, 5500, 6000, fs / 2.0]) / fs desired = [0, 1, 0] b = remez(513, bands, desired) sig_filt = lfilter(b, 1, sig) sig_filt /= 1.05 * max(abs(sig_filt)) # normalize subplot(211) specgram(sig, Fs=fs, NFFT=1024, noverlap=0) axis('tight') axis(ymax=8000) title('Original') subplot(212) specgram(sig_filt, Fs=fs, NFFT=1024, noverlap=0) axis('tight') axis(ymax=8000) title('Filtered') show() play(sig_filt, fs)
def play_segment(segment): audiolab.play(segment["raw"].mean(axis=1))
def play(self, example): sound = audiolab.sndfile(self.base + example.file) frames = sound.read_frames(sound.get_nframes()) * 0.8 audiolab.play(frames[example.start:example.stop][:, 0])
contours2 = cv2.findContours(mask2.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2] note, note2 = np.array([]), np.array([]) if len(contours) > 0: c1 = max(contours, key=cv2.contourArea) if cv2.contourArea(c1) > MIN_OBJECT_AREA: m = cv2.moments(c1) center = (int(m['m10'] / m['m00']), int(m['m01'] / m['m00'])) center_x = center[0] note = pick_note(center_x, t, FRAME_SPLIT) if len(contours2) > 0: c2 = max(contours2, key=cv2.contourArea) if cv2.contourArea(c2) > MIN_OBJECT_AREA: m = cv2.moments(c2) center = (int(m['m10'] / m['m00']), int(m['m01'] / m['m00'])) center_x = center[0] note2 = pick_note(center_x, t, FRAME_SPLIT) if note.size and note2.size: audiolab.play(note + note2) elif note.size: audiolab.play(note) elif note2.size: audiolab.play(note2) if cv2.waitKey(1) & 0xFF == ord('q'): break cv2.imshow('image2', mask) # When everything done, release the capture cap.release() cv2.destroyAllWindows()
def play(self): au.play( self.data.astype(float) / self.data.max(), fs=self.params['sample_rate'])
def play(self, speed_scale=None): if speed_scale is not None: fs = self.samplerate * speed_scale else: fs = self.samplerate audiolab.play(self.waveform, fs)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv, lower, upper) mask = cv2.erode(mask, None, iterations=2) mask = cv2.dilate(mask, None, iterations=2) contours = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2] if len(contours) > 0: c1 = max(contours, key=cv2.contourArea) m = cv2.moments(c1) center = (int(m['m10'] / m['m00']), int(m['m01'] / m['m00'])) center_x = center[0] if center_x < FRAME_SPLIT: audiolab.play(a) elif center_x < FRAME_SPLIT * 2: audiolab.play(g) elif center_x < FRAME_SPLIT * 3: audiolab.play(e) elif center_x < FRAME_SPLIT * 4: audiolab.play(d) elif center_x < FRAME_SPLIT * 5: audiolab.play(c) if cv2.waitKey(1) & 0xFF == ord('q'): break cv2.imshow('image2', mask) # When everything done, release the capture cap.release() cv2.destroyAllWindows()
[-12, 59.0207, 0.0501209, 0.000840648, 5.48635, 2554.66, 503.88, 0.79761, 1.83648, 1.58787, 1.03476, 0.896911, 0.996907, 1.24554, 0.845971, 0.148589], [-12, 61.0691, -0.0588209, -0.00162663, 5.50909, 2433.82, 496.385, 0.801913, 1.90018, 1.45739, 0.653615, 1.00535, 1.29864, 1.52989, 0.585408, 0.104115], [-12, 58.398, 0.0678559, 0.00801878, 5.49513, 2584.1, 503.088, 0.798411, 1.90384, 1.44329, 0.612329, 1.01709, 1.30643, 1.5384, 0.560051, 0.102344], [-12, 58.1282, -0.0770835, 0.0391217, 5.49927, 2374.82, 497.716, 0.801403, 1.88149, 1.43979, 0.625468, 1.01567, 1.28775, 1.51369, 0.586579, 0.0976503], [-12, 43.657, 0.0862755, 0.201883, 5.52524, 2865.47, 501.169, 0.798652, 1.75618, 1.45495, 0.770813, 0.987832, 1.03016, 1.25533, 0.740417, 0.102236], [-12, 10.3548, -0.0950456, 0.680794, 5.79356, 5315.03, 500.314, 0.801417, 1.40392, 1.48089, 1.14573, 0.919835, 0.385726, 0.587562, 1.20079, 0.0979321], [-12, -0.394881, 0.102688, 0.780489, 5.79459, 5594.09, 497.703, 0.798394, 1.31567, 1.48965, 1.24365, 0.900246, 0.203358, 0.406455, 1.2852, 0.101868], [-12, 1.30799, -0.107779, 0.822941, 5.81101, 5389.04, 505.148, 0.80191, 1.31808, 1.49677, 1.26002, 0.900181, 0.215266, 0.413344, 1.2873, 0.0983526], [-12, -1.52704, 0.107008, 0.668792, 5.77274, 5679.06, 489.624, 0.797668, 1.34557, 1.53307, 1.32862, 0.8885, 0.221463, 0.42741, 0.784301, 0.101409], [-12, 2.02356, -0.090766, -0.0265786, 6.19917, 4187.48, 575.678, 0.802868, 1.42662, 1.62262, 1.48196, 0.874043, 0.302706, 0.511677, 0.0893865, 0.0988436], [-12, -3.41672, 0.0162316, 0.0680242, 7.12928, 1914.69, 707.314, 0.796474, 1.50667, 1.71846, 1.65847, 0.846687, 0.354325, 0.575671, 0.140095, 0.100891], [-12, 16.0217, 2.36331, 0.151462, 6.2577, 2295.98, 614.831, 0.80431, 1.60145, 1.8245, 1.8373, 0.832248, 0.444953, 0.671848, 0.664881, 0.0993871], [-12, 55.8366, 0.591923, -0.02722, 5.34712, 2513.69, 460.645, 0.794764, 1.64483, 1.87722, 1.94201, 0.80983, 0.469025, 0.701948, 1.36649, 0.100323], [-12, 58.5214, -0.448925, 0.013885, 5.60332, 2498.36, 539.471, 0.806323, 1.6737, 1.90901, 1.98537, 0.817279, 0.501886, 0.740232, 1.45146, 0.0999809], [-12, 59.9655, 0.438486, -0.00911093, 5.40836, 2497.41, 452.571, 0.792391, 1.64345, 1.88704, 1.97305, 0.810446, 0.454063, 0.720752, 1.4588, 0.0996983], [-12, 49.3266, -0.465215, 0.00669799, 5.59228, 2506.42, 562.858, 0.809152, 1.60705, 1.87666, 1.96538, 0.849748, 0.391025, 0.759315, 1.30988, 0.100646], [-12, 18.1282, 0.520405, -0.00501896, 5.39967, 2488.55, 406.339, 0.78894, 1.4451, 1.77875, 1.89589, 0.887862, 0.141397, 0.75315, 1.01718, 0.0989738], [-12, 2.22709, -0.615666, 0.0025473, 5.64094, 2518.53, 1187.9, 0.813524, 1.40047, 1.77117, 1.89445, 0.943704, 0.0548771, 0.806182, 0.839183, 0.101466], [-12, 0.733967, 0.793145, 0.0172693, 5.45811, 2471.1, 2316.01, 0.78307, 1.34412, 1.72004, 1.85292, 0.921577, -0.00849037, 0.762973, 0.802398, 0.0979881], [-12, -0.201343, -1.21956, 0.164671, 5.77113, 2545.27, 2798.41, 0.822155, 1.35851, 1.7255, 1.83304, 0.951667, 0.0887088, 0.849571, 0.742676, 0.102774], [-12, 0.0790298, 4.48401, 0.144665, 5.31437, 2424.68, 1322.22, 0.768336, 1.22142, 1.53669, 1.60628, 0.870119, 0.188809, 0.836472, 0.620848, 0.0959391] ]) w = numpy.array(f) w /= abs(w).max() play(w, 22050) for target in 'music oi'.split(): print 'synthesizing %s.gnuspeech' % target lmj.trm.synthesize(target + '.gnuspeech', target + '.wav') subprocess.call(['aplay', target + '.wav'])
from scikits.audiolab import wavread from scikits.audiolab import play # specify a file name filename = "viola.wav" # extract audio from file samples, fs, enc = wavread(filename) # print out the first 50 samples print samples[0:50] ################################################# ############# PLAYING AN AUDIO FILE ############# ################################################# # play the audio file data in 'data' at 44100Hz play(samples,fs=44100) ################################################# ################################################# #################################################
def playSound(self): al.play(self._ramped(self.s2, self.fs), self.fs)
overtones = [2,3,4,5,6,7,8] overamps = [0.08,0.05,0.01,0.005,0.001,0.0001,0.00001] tune = np.zeros((2,len(melody)*(samples))) for j in range(len(melody)): tone = melody[j] f_sin = NOTES[tone] ground = np.sin(f_sin/f_sample*np.arange(samples)) sig = ground for i in np.arange(len(overtones)): n = overtones[i] relamp = overamps[i] overtone = relamp*np.sin(f_sin*n/f_sample*np.arange(samples)) sig = np.add(sig,overtone) sig = amplitude*np.multiply(sig,tone_shape) tstart = j*samples tstop = (j+1)*samples tune[0,tstart:tstop] = sig tune[1,tstart:tstop] = sig print f_sample print len(tune[0])/len(melody) #plt.plot(tune[0]) #plt.show() al.play(tune[0],f_sample)
def play(self, index): if index < 0: self.train.mixdown() al.play(self.train.sound.wav, self.train.sound.rate) else: al.play(self.sounds[index].wav, self.sounds[index].rate)
def play(f, fs): """TODO: filter high frequencies or raise error when f > 800 Hz""" # if spectrum(f) return al.play(f, fs)
#!/usr/bin/env python from utils import imfcc import numpy as np from scikits.audiolab import wavwrite, play CLUSTER_FILE = '../old_data/kmeans/clusters_rand_5000.txt' PLAYING = False clusters = np.loadtxt(CLUSTER_FILE)[:, 1:] for cluster in clusters: x = np.tile(cluster, (51, 1)) y = imfcc(x, has_power=False) if PLAYING: play(y, fs=44100) else: wavwrite(y, 'test.wav', fs=44100, enc='pcm16') break
import numpy as np from scikits.audiolab import play # output one second of stereo gaussian white noise at 48000 hz data = np.random.randn(2, 480000) play(0.001 * data)