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