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()
def stream_audio():
s = Stream(samplerate=RATE, blocksize=CHUNK, callback=process_chunk)
s.start()
try:
secs = 1000
print("Controlling cursor for %d seconds, Ctrl-C to stop" % secs)
time.sleep(secs)
except KeyboardInterrupt:
pass
print("Stopping...")
s.stop()
def main():
vo = VoiceOver()
soundcard = Stream(
blocksize=BLOCK_SIZE,
channels=1,
dtype='int16',
samplerate=44100,
callback=vo.callback,
)
soundcard.start()
while True:
time.sleep(5)
soundcard.stop()
def play_source(source_path):
"""Play an audio file using pysoundcard."""
from aubio import source
from pysoundcard import Stream
hop_size = 256
f = source(source_path, hop_size=hop_size)
samplerate = f.samplerate
s = Stream(sample_rate=samplerate, block_length=hop_size)
s.start()
read = 0
while 1:
vec, read = f()
s.write(vec)
if read < hop_size: break
s.stop()
def play_source(source_path):
"""Play an audio file using pysoundcard."""
from aubio import source
from pysoundcard import Stream
hop_size = 256
f = source(source_path, hop_size = hop_size)
samplerate = f.samplerate
s = Stream(sample_rate = samplerate, block_length = hop_size)
s.start()
read = 0
while 1:
vec, read = f()
s.write(vec)
if read < hop_size: break
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()
class Player(object):
BUFFER_SIZE = 0.25 # in seconds
def __init__(self):
"""
"""
self.fObj = None
self.track = None # the currently playing SoundFile
self.buffer_size = 0 # the number of PCM frames to process
self.state = PLAYER_STOPPED
self.progress = [0, 1] # an Array of current/total frames
self.task = None
#self.stream = Stream(callback=self.stream_callback)
self.stream = Stream()
self.queue = deque()
self.played = deque()
def enqueue(self, fObj):
self.queue.append(fObj)
def close(self):
self.stop_playing()
def pause(self):
if (self.state == PLAYER_PLAYING):
self.task.pause()
self.stream.stop()
self.state = PLAYER_PAUSED
def play(self):
log.msg('Play: %r, %d' % (self.track, len(self.queue)))
if self.track is None and self.queue:
self.fObj = self.queue.popleft()
self.track = SoundFile(self.fObj, virtual_io=True)
if (self.track is not None):
if (self.state == PLAYER_STOPPED):
self.start_playing()
elif (self.state == PLAYER_PAUSED):
self.stream.start()
self.task.resume()
self.state = PLAYER_PLAYING
elif (self.state == PLAYER_PLAYING):
pass
def next_track(self):
self.stop_playing()
self.play()
def previous_track(self):
self.queue.appendleft(self.played.pop())
self.stop_playing()
self.play()
def toggle_play_pause(self):
if (self.state == PLAYER_PLAYING):
self.pause()
elif ((self.state == PLAYER_PAUSED) or
(self.state == PLAYER_STOPPED)):
self.play()
def start_playing(self):
self.buffer_size = min(int(round(self.BUFFER_SIZE *
self.track.sample_rate)),
2048)
log.msg('buf size: %s' % self.buffer_size)
#reopen stream if necessary based on file's parameters
if self.stream.sample_rate != self.track.sample_rate or \
self.stream.block_length != self.buffer_size:
self.stream = Stream(sample_rate=self.track.sample_rate,
block_length=self.buffer_size)
#callback=self.stream_callback)
self.state = PLAYER_PLAYING
self.stream.start()
#self.set_progress(0, self.track.frames)
self.task = cooperate(self)
def stop_playing(self):
if self.task is not None:
self.task.stop()
self.task = None
if self.state > PLAYER_STOPPED:
self.state = PLAYER_STOPPED
if self.stream.is_active():
self.stream.stop()
self.set_progress(0, 1)
if self.track is not None:
self.track = None
self.fObj.close()
self.played.append(self.fObj)
self.fObj = None
def stream_callback(self, in_data, frame_count, time_info, status):
# This method doesn't seem to play nice with Twisted.
# It seems to behave as a large blocking thread;
# i.e., not releasing back to Twisted after each iteration
out_data = self.track.read(frame_count)
self.progress[0] += len(out_data)
if self.progress[0] < self.track.frames:
if len(out_data) >= frame_count:
return (out_data, continue_flag)
else:
return (out_data, complete_flag)
else:
return (out_data, complete_flag)
def output_chunk(self):
frame = self.track.read(self.buffer_size)
frame_len = len(frame)
if (frame_len > 0):
self.progress[0] += frame_len
self.stream.write(frame)
return frame_len
else:
self.stop_playing()
def set_progress(self, current, total):
self.progress[0] = current
self.progress[1] = total
def __iter__(self):
#log.msg('__iter__')
return self
def next(self):
#log.msg('next state: %s' % self.state)
if self.state == PLAYER_PLAYING:
return self.output_chunk()
else:
raise StopIteration
## Signal erzeugen und abspielen ## bei mir stürzt ipython3 leider nach dem Rauschen ab! noch unklar warum import numpy as np from pysoundcard import Stream block_length = 1024 fs =44100 time = 3 sample = time*fs data = np.random.uniform(-0.7,0.7,sample) s = Stream(fs, block_length) s.start() s.write(data) s.stop() s.stop()
class SlmWebSocket(tornado.websocket.WebSocketHandler):
def open(self):
print("WebSocket opened")
self.set_exponential_smoothing_tau(tau=tau)
self.init_stream(sample_rate=sample_rate,
block_length=block_length)
self.start_stream()
def on_message(self, message):
if '#start#' in message:
self.start_stream()
if '#stop#' in message:
self.stop_stream()
if '#set_tau#' in message:
msg = message.split()
print(msg)
if len(msg)>1:
tau = float(msg[1])
self.set_exponential_smoothing_tau(tau)
def on_close(self):
print("Websocket is closed")
def set_exponential_smoothing_tau(self, tau):
if tau > 0:
alpha = np.exp(-1.0/(tau*(sample_rate/block_length)))
self._b0 = 1 - alpha
self._a1 = -alpha
print("Tau accepted.")
else:
print("Tau '{}' not accepted.".format(tau))
def init_stream(self, sample_rate, block_length):
self._psc_sample_rate = sample_rate
self._psc_block_length = block_length
self._level = -120
def callback(in_data, frame_count, time_info, status):
new_value = self._b0*np.mean(in_data**2) - self._a1*10**(self._level*0.1)
self._level = 10*np.log10(new_value)
self.write_message('{:.1f}'.format(self._level))
return in_data, continue_flag
self._psc_stream = Stream(
callback=callback,
sample_rate=self._psc_sample_rate,
block_length=self._psc_block_length,
output_device=False
)
def start_stream(self):
if not self._psc_stream.is_active():
print('Start stream')
self._psc_stream.start()
def stop_stream(self):
if self._psc_stream.is_active():
print('Stop stream')
self._psc_stream.stop()
