def audio_thread(): print("Starting Audio") global reading_data global win fs = 48000 fftLength = 255 blocksize = 255 bin_bandwidth = fs / fftLength avg_num = 10 s = Stream(samplerate=fs, blocksize=blocksize) s.start() psd = [0] * fftLength while reading_data: data = s.read(fftLength) left, right = map(list, zip(*data)) out = np.fft.rfft(left) psd[0] = average(psd[0], calc_psd(out[0].real, out[0].real, bin_bandwidth), avg_num) half = int(len(out)) for k in range(1, half): psd[k] = average(psd[k], calc_psd(out[k].real, out[k].imag, bin_bandwidth), avg_num) psd[half - 1] = average( psd[k], calc_psd(out[0].imag, out[half - 1].imag, bin_bandwidth), avg_num) if (reading_data): win.setData(psd) s.stop()
class SysAudioStream(object): """Loop back system audio.""" def __init__(self, rate, blocksize): self._rate = rate self._blocksize = blocksize self._buff = queue.Queue() self.closed = True def __enter__(self): self._audio_stream = Stream(samplerate=self._rate, blocksize=self._blocksize) self._audio_stream.start() self.closed = False def __exit__(self, type, value, traceback): self._audio_stream.stop() self.closed = True # Signal the generator to terminate so that the client's # streaming_recognize method will not block the process termination. self._buff.put(None) def generator(self): while not self.closed: # Use a blocking get() to ensure there's at least one chunk of # data, and stop iteration if the chunk is None, indicating the # end of the audio stream. chunk = self._audio_stream.read(16) if chunk is None: return data = [chunk] # Now consume whatever other data's still buffered. # while True: # try: # chunk = self._buff.get(block=False) # if chunk is None: # return # data.append(chunk) # except queue.Empty: # break yield b''.join(data)
def record_sink(sink_path): """Record an audio file using pysoundcard.""" from aubio import sink from pysoundcard import Stream hop_size = 256 duration = 5 # in seconds s = Stream(block_length=hop_size) g = sink(sink_path, samplerate=s.sample_rate) s.start() total_frames = 0 while total_frames < duration * s.sample_rate: vec = s.read(hop_size) # mix down to mono mono_vec = vec.sum(-1) / float(s.input_channels) g(mono_vec, hop_size) total_frames += hop_size s.stop()
def record_sink(sink_path): """Record an audio file using pysoundcard.""" from aubio import sink from pysoundcard import Stream hop_size = 256 duration = 5 # in seconds s = Stream(block_length = hop_size) g = sink(sink_path, samplerate = s.sample_rate) s.start() total_frames = 0 while total_frames < duration * s.sample_rate: vec = s.read(hop_size) # mix down to mono mono_vec = vec.sum(-1) / float(s.input_channels) g(mono_vec, hop_size) total_frames += hop_size s.stop()
class InputStream(Stream): def __init__(self, device=None): super(self.__class__, self).__init__() self.device = device if device is not None else self._findDevice() self.sr = consts.sr self.inputStream = PyScStream( sample_rate=self.sr, block_length=consts.window_hop, callback=self.inputStreamCallback, input_device=self.device) self.iteration = 0 def _findDevice(self): inputPriority = [ "FastTrack Pro", "Built-in Input", "Soundflower (2ch)", ] for input_ in inputPriority: for dev in pysoundcard.devices(): if dev['name'] == input_ and dev['input_channels'] > 0: return dev def inputStreamCallback(self, inData, numFrames, timeInfo, status): ''' Wrap our stream callback in the default pysoundcard callback ''' self.iteration += 1 if self.iteration % 3 == 0: print "%.2f" % np.sum(inData) self.enqueueChunk(inData) return (np.zeros((numFrames, 2)), pysoundcard.continue_flag) def read(self, *args, **kwargs): return self.inputStream.read(*args, **kwargs) def start(self): self.inputStream.start() def stop(self): self.inputStream.stop()
def iter_capture_and_detect_gender(sample_rate=11025, hop_size=256, confidence_threshold=0.8): """Capture audio and yield gender. Parameters ---------- sample_rate : int Sample rate in Hertz confidence_threshold : float Pitch confidence threshold for yielding Yields ------ gender : str String representing gender either 'male' or 'female' """ stream = Stream(blocksize=hop_size, channels=1, samplerate=sample_rate) stream.start() try: while True: samples = stream.read(hop_size).flatten() pitch_and_confidence = get_pitches(samples, buf_size=hop_size, hop_size=hop_size, sample_rate=sample_rate) pitch = pitch_and_confidence[0, 0] confidence = pitch_and_confidence[0, 1] if pitch > 145: gender = 'female' else: gender = 'male' if confidence >= confidence_threshold: yield gender except KeyboardInterrupt: pass stream.stop()
def track_energy(): """Track attacks of instrument, maintain global float energy""" global energy energy = 0.25 win_size = 512 # fft size hop_size = 256 s = Stream(block_length = hop_size) o = onset("default", win_size, hop_size, s.sample_rate) come_up_steps = ceil(come_up_secs * s.sample_rate/hop_size) built_energy = 0 built_steps = 0 onsets = 0 s.start() while True: vec = s.read(hop_size) # mix down to mono mono_vec = vec.sum(-1) / float(s.input_channels) if o(mono_vec): print "beat" + str(onsets) onsets += 1 built_energy = (nu * (energy + built_steps * built_energy) + (1-nu) - energy)/(built_steps+come_up_steps) built_steps += come_up_steps if built_steps == 0 : energy = (1-eta) * energy else: energy += built_energy built_steps -= 1 # print "energy = %f, total = %f" % (energy,energy + built_energy * built_steps) s.stop()
def iter_capture_and_detect_gender(sample_rate=11025, hop_size=256, confidence_threshold=0.8): """Capture audio and yield gender. Parameters ---------- sample_rate : int Sample rate in Hertz confidence_threshold : float Pitch confidence threshold for yielding Yields ------ gender : str String representing gender either 'male' or 'female' """ stream = Stream(blocksize=hop_size, channels=1, samplerate=sample_rate) stream.start() try: while True: samples = stream.read(hop_size).flatten() pitch_and_confidence = get_pitches( samples, buf_size=hop_size, hop_size=hop_size, sample_rate=sample_rate) pitch = pitch_and_confidence[0, 0] confidence = pitch_and_confidence[0, 1] if pitch > 145: gender = 'female' else: gender = 'male' if confidence >= confidence_threshold: yield gender except KeyboardInterrupt: pass stream.stop()
def record_sink(sink_path): """Record an audio file using pysoundcard.""" from aubio import sink from pysoundcard import Stream hop_size = 256 duration = 5 # in seconds s = Stream(blocksize = hop_size, channels = 1) g = sink(sink_path, samplerate = int(s.samplerate)) s.start() total_frames = 0 try: while total_frames < duration * s.samplerate: vec = s.read(hop_size) # mix down to mono mono_vec = vec.sum(-1) / float(s.channels[0]) g(mono_vec, hop_size) total_frames += hop_size except KeyboardInterrupt: duration = total_frames / float(s.samplerate) print("stopped after %.2f seconds" % duration) s.stop()
def record_sink(sink_path): """Record an audio file using pysoundcard.""" from aubio import sink from pysoundcard import Stream hop_size = 256 duration = 5 # in seconds s = Stream(blocksize=hop_size, channels=1) g = sink(sink_path, samplerate=int(s.samplerate)) s.start() total_frames = 0 try: while total_frames < duration * s.samplerate: vec = s.read(hop_size) # mix down to mono mono_vec = vec.sum(-1) / float(s.channels[0]) g(mono_vec, hop_size) total_frames += hop_size except KeyboardInterrupt: duration = total_frames / float(s.samplerate) print("stopped after %.2f seconds" % duration) s.stop()
from pysoundcard import Stream """Loop back five seconds of audio data.""" fs = 44100 block_length = 16 s = Stream(sample_rate=fs, block_length=block_length) s.start() for n in range(int(fs * 5 / block_length)): s.write(s.read(block_length)) s.stop()
# Rauschen abspielen und kontinuierlich in Blöcken aufnehmen from pysoundcard import Stream import pysoundcard import numpy as np fs = 44100 block_length = 1024*8 s = Stream(sample_rate=fs, block_length=block_length) time = 1 # Laenge des Rauschens in Sekunden noise = np.random.randn(block_length,2)/20.0 n_blocks = int(fs*time/block_length) # für das erste hinzufügen des ersten arrays einen start arry # in passender größe, hier erstmal Nullen rec_file=np.zeros([block_length,2],float) s.start() for n in range(n_blocks): s.write(noise) rec = s.read(block_length) rec_file=np.vstack([rec_file,rec]) # hinzufügen des aufgenommenen blocks zu rec_file als zeilenvektor in einem array! #s.write(rec_file) #print(rec_file) s.stop()
n_down_plot = 50 #Variable Anzahl Plotts pro Sekunde ############ Stream mit Zugriffswegen fuer externe Soundkarte ########## s = Stream(sample_rate = fs, block_length = block_length, input_device_index = 1, #im CommandWindow den Weg herausfinden mit import pyaudio, py=pyaudio.PyAudio(), pa.get_device_info_by_index(NUMMERVERSUCH) output_device_index = 4) fig, ax = plt.subplots() s.start() plt.show(block=False) #Plot wird im Fenster gelöscht und neu geschrieben ca_whole_record = [] num_of_blocks = int(fs*record_seconds/block_length) line, = ax.plot(np.random.randn(num_of_blocks)*15-50) #Skalierung der y-Achse pegel = np.zeros(num_of_blocks) #Nullvektor erstellen als Ausgang for n in range(num_of_blocks): #geht die Schleife solange durch, bis ca_record = s.read(block_length) pegel[n] = 10*np.log10(np.sum(np.square(ca_record))/block_length) #Pegel auf logarithmischer y-Achse darstellen ca_whole_record.append(ca_record) #haengt alle in blocklaenge aufgenommenes Array if np.mod(n, n_down_plot) == 0: #Modul-Befehl fuer Rest berechnen, damit nur soviel wie n_down_plot im Plotfenster gezeigenangezeigt wird line.set_ydata(pegel) ax.draw_artist(ax.patch) ax.draw_artist(line) fig.canvas.update() fig.canvas.flush_events() s.stop() print ("* done recording")
from pysoundcard import Stream """Loop back five seconds of audio data.""" fs = 44100 blocksize = 16 s = Stream(samplerate=fs, blocksize=blocksize) s.start() for n in range(int(fs * 5 / blocksize)): s.write(s.read(blocksize)) s.stop()
from pysoundcard import Stream """Loop back five seconds of audio data.""" fs = 44100 block_length = 16 s = Stream(sample_rate=fs, block_length=block_length) s.start() for n in range(int(fs*5/block_length)): s.write(s.read(block_length)) s.stop()