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()
## 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 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
import sys import numpy as np from scipy.io.wavfile import read as wavread from pysoundcard import Stream """Play an audio file.""" fs, wave = wavread(sys.argv[1]) wave = np.array(wave, dtype=np.float32) wave /= 2**15 # normalize -max_int16..max_int16 to -1..1 block_length = 16 s = Stream(sample_rate=fs, block_length=block_length) s.start() s.write(wave) s.stop()
""" import sys, os import numpy as np from scipy.io.wavfile import read as wavread from pysoundcard import Stream () path = '/home/muenker/Daten/share/Musi/wav/' #path = '../_media/' #filename = 'chord.wav' filename = '07 - Danny Gottlieb with John McLaughlin - Duet.wav' filename = 'Ole_16bit.wav' # filename = '01 - Santogold - L.E.S Artistes.wav' filename = '01 - Santogold - L.E.S Artistes_20s.wav' #filename = 'ComputerBeeps2.wav' filename = 'SpaceRipple.wav' fs, wave = wavread(os.path.join(path, filename)) """Play an audio file.""" #fs, wave = wavread(sys.argv[1]) wave = np.array(wave, dtype=np.float32) wave /= 2**15 # normalize -max_int16..max_int16 to -1..1 blocksize = 512 s = Stream(samplerate=fs, blocksize=blocksize) s.start() s.write(wave) 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()
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()
import sys
import numpy as np
from scipy.io.wavfile import read as wavread
from pysoundcard import Stream
"""Play an audio file."""
fs, wave = wavread(sys.argv[1])
wave = np.array(wave, dtype=np.int16)
blocksize = 256
s = Stream(samplerate=fs, blocksize=blocksize, dtype='int16')
s.start()
while True:
s.write(wave[0:(1024 * 100)])
s.stop()
#Checking if Auto Mode
default_chord = ""
if (getClassLabel((data_name.split('_'))[0]) != -1):
default_chord = (data_name.split('_'))[0]
print("Auto mode")
output_data = []
previous_chord = "null"
num_chords = 0
for beat_data in data:
print("For beat " + str(beat_no))
sys.stdout.write("\033[F")
if (default_chord == ""):
s.start()
for samples in beat_data:
s.write(samples)
if (default_chord == ""):
chord = raw_input("Enter chord:" + str(keys) + " " + str(variations) +
" : ")
else:
previous_chord = default_chord
chord = ""
print("Using default chord : " + default_chord)
if (chord == ""):
if (previous_chord == "null"):
print("First time. Passing.")
sys.stdout.write("\033[F")
else:
if (default_chord == ""):
print("Using previos chord:" + previous_chord)
chord = previous_chord
