def __init__(self, pitch=0, pitch_per_second=12, decibels=0, decibels_per_second=1, channels=1, channel_side="lr", samplerate=utilities.DEFAULT_SAMPLE_RATE): self.sinewave_generator = sinewave_generator.SineWaveGenerator( pitch=pitch, pitch_per_second=pitch_per_second, decibels=decibels, decibels_per_second=decibels_per_second, samplerate=samplerate) # Create the output stream self.output_stream = sd.OutputStream( channels=channels, callback=lambda *args: self._callback(*args), samplerate=samplerate) self.channels = channels if channel_side == 'r': self.channel_side = 0 elif channel_side == 'l': self.channel_side = 1 else: self.channel_side = -1
def __init__(self, stationMHz): self.sdr = rtlsdr.RtlSdr() self.validsGains = self.sdr.get_gains() self.indexGain = 10 self.f_offset = 250000 # Desplazamiento para capturar self.f_station = stationMHz # Frecuencia de radio self.dec_rate = int(FS / F_BW) self.fs_y = FS / (self.dec_rate) self.coef = remez(N_TRAPS, [0, F_BW, F_BW * 1.4, FS / 2], [1, 0], Hz=FS) self.expShift = (-1.0j * 2.0 * np.pi * self.f_offset / FS) # Se configura los parametros self.dec_audio = int(self.fs_y / AUDIO_FREC) self.stream = sd.OutputStream(device='default', samplerate=int(self.fs_y / self.dec_audio), channels=1, dtype='float32') self.beginListening = 0 self.soundQueue = queue.Queue() self.samplesQueue = queue.Queue()
def receive(self, listening_port, number_of_chunks_received): if __debug__: print(f"receive: listening_port={listening_port}") # UDP socket to receive self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) listening_endpoint = ("0.0.0.0", listening_port) self.sock.bind(listening_endpoint) def callback(outdata, frames, time, status): outdata, source_address = self.sock.recvfrom(Intercom.max_packet_size) number_of_chunks_received.value += 1 with sd.OutputStream( samplerate=self.samples_per_second, blocksize=self.samples_per_chunk, device=None, channels=self.number_of_channels, dtype=numpy.int16, callback=callback): while True: time.sleep(1) print("o") while True: callback(None, None, None, None)
def easy_sound(freq, pos, decay, fbins): stream = sd.OutputStream(dtype = np.int16, channels=2) stream.start() time = 0.4 wave = 0; samples = np.arange(44100*1*time)/44100.0 count = 0 for i in range(len(fbins)): if (fbins[i]*freq > 20000.0): break count += 1 cf = fbins[i]*freq idf = 0.005 a = np.sin(np.pi*(i+1)*pos/1.0)/(343*fbins[i]*freq) alpha = (1/4)*1*(2-(np.sin(2*np.pi*(i+1))/(np.pi * (i+1)))) a /= alpha print(str(i) + " " + str(a)) wave += a * np.exp(-decay*cf*idf*samples) * np.sin(2*np.pi*(fbins[i]*freq)*samples) count = 1/count wave *= count # for i in range(len(wave)): # print(wave[i]) # wave[i] *= np.exp(-decay*(i/44100)) wav_wave = np.array(wave/np.max(np.abs(wave))*32767, dtype=np.int16) stream.write(wav_wave) stream.close() # scipy.io.wavfile.write(str(freq) + '.wav', 44100, wav_wave) return wav_wave
def __init__(self, audioformat, queue=None): """Constructor. Creates a pyaudio sound renderer. Parameters ---------- audioformat : dict A dictionary containing the properties of the audiostream queue : Queue.queue A queue object which serves as a buffer on which the individual audio frames are placed by the decoder. """ global sd import sounddevice as sd # Init thread super(SoundrendererSounddevice, self).__init__() if not queue is None: self.queue = queue self.stream = sd.OutputStream( channels=audioformat["nchannels"], samplerate=audioformat["fps"], dtype='int{}'.format(audioformat['nbytes'] * 8), blocksize=audioformat["buffersize"], )
def __init__(self, out_bufferL, out_bufferR, out_i, outlock): self.out_bufferL = out_bufferL self.out_bufferR = out_bufferR self.out_i = out_i self.zeros = np.zeros(config.BUFFERSIZE, dtype=np.float32) self.outlock = outlock sd.default.device = config.DEVICE sd.default.samplerate = config.SAMPLERATE sd.default.latency = 'low' logging.info('>> AUDIO OUTPUTS:\n{}'.format(sd.query_devices())) logging.info('>> AUDIO OUTPUT: {}'.format(config.DEVICE)) self.last_looptime = 0 self.lastoutbuffer = None if config.AUTORECORD: self.soundfile = sf.SoundFile('{}.wav'.format( datetime.datetime.timestamp(datetime.datetime.now())), 'w', samplerate=config.SAMPLERATE, channels=config.NCHANNELS) with sd.OutputStream(dtype=config.CAST, channels=config.NCHANNELS, callback=self.callback, blocksize=config.BUFFERSIZE) as self.stream: while True: time.sleep(config.SLEEPTIME)
def stream_func(device=-1, chunk=256): def callback(outdata, frames, time, status): try: data = next(sound_slice) if flags_stream_trem[0] is False: raise sd.CallbackStop else: outdata[:, :] = data except ValueError: outdata[:, :] = np.zeros((blocksize, 2)) def gen(): global sound sound = np.zeros((blocksize, 2)) while True: slice = sound[:blocksize, :] yield slice sound = sound[blocksize:, :] blocksize = chunk sound_slice = gen() device = device if device >= 0 else None stream = sd.OutputStream(device=device, channels=2, callback=callback, blocksize=blocksize, samplerate=sample_rate) with stream: while flags_stream_trem[0] is True: time.sleep(0.5) else: stream.__exit__()
def _process_playback_command(self, cmd): phase_offset = 0 cfg = cmd.config # Make the code adaptive to both python 2 and 3 shared_vars = {"cmd": cmd, "phase_offset": phase_offset} def playback_cb(outdata, frames, time, status): phase_offset = shared_vars["phase_offset"] cmd = shared_vars["cmd"] cfg = cmd.config signal = np.arange(outdata.shape[0]) signal = signal * 2 * np.pi / cfg.fs + phase_offset phase_offset += outdata.shape[0] * 2 * np.pi / cfg.fs signal = 0.99 * np.sin(signal * cmd.out_freq) for cidx in range(outdata.shape[1]): outdata[:, cidx] = signal shared_vars["phase_offset"] = phase_offset shared_vars["cmd"] = cmd with sd.OutputStream(channels=cfg.ch, callback=playback_cb, samplerate=cfg.fs, dtype="float32"): while cmd.is_playing: sd.sleep(500)
def _playback(self): phase_offset = 0 # Make the code adaptive to both python 2 and 3 shared_vars = {"phase_offset": phase_offset, "data": self.data} def playback_cb(outdata, frames, time, status): phase_offset = shared_vars["phase_offset"] data = shared_vars["data"] signal = np.arange(outdata.shape[0]) signal = signal * 2 * np.pi / self.sr + phase_offset phase_offset += outdata.shape[0] * 2 * np.pi / self.sr signal = 0.99 * np.sin(signal * 440) for cidx in range(outdata.shape[1]): outdata[:, cidx] = data[cidx] #outdata[:, cidx] = signal shared_vars["phase_offset"] = phase_offset with sd.OutputStream(channels=self.ch, callback=playback_cb, samplerate=self.sr, dtype="float32"): while self.is_playing: sd.sleep(500)
def open_output_stream(device=None, channels=2, samplerate=44100): global output_stream if sd: output_stream = sd.OutputStream( dtype='float32' ) # device=device, samplerate=samplerate, latency='low', clip_off=True, dither_off=True, never_drop_input=True) output_stream.start()
def __init__(self, device_name=None, sample_rate=44100): """ Create a control voltage output device. Control voltage signals require a DC-coupled audio interface, which Python sends audio signals to via the sounddevice library. Args: device_name (str): Name of the audio output device to use. To query possible names, call get_cv_output_devices(). sample_rate (int): Audio sample rate to use. """ try: self.stream = sounddevice.OutputStream( device=device_name, samplerate=sample_rate, dtype="float32", callback=self.audio_callback) self.stream.start() except NameError: raise Exception( "For CV support, the sounddevice module must be installed") # Expert Sleepers ES-8 supports entire -10V to +10V range self.output_voltage_max = 10 self.channels = self.stream.channels self.channel_notes = [None] * self.channels self.middle_c = 60 print("Started CV output with %d channels" % self.channels)
def __init__(self, mode, streamOptions={}, dataQueue=None, rw_autoStop=True, stopwatch=StopWatch(error=False)): self.mode = mode if self.mode == "rw": if not "callback" in streamOptions: streamOptions.update(callback=self._Queue2) self.sdStream = sounddevice.Stream(dtype="float32", **streamOptions) self.rw_autoStop = rw_autoStop elif self.mode == "r": if not "callback" in streamOptions: streamOptions.update(callback=self._Queue) self.sdStream = sounddevice.InputStream(dtype="float32", **streamOptions) elif self.mode == "w": if not "callback" in streamOptions: streamOptions.update(callback=self._Queue) self.sdStream = sounddevice.OutputStream(dtype="float32", **streamOptions) else: raise ModeError("Unknown mode.") if dataQueue is None: if self.mode == "rw": self.dataQueue = (queue.Queue(), queue.Queue()) else: self.dataQueue = queue.Queue() else: self.dataQueue = dataQueue self.state = "stop" self.stopwatch = stopwatch self.last_frametime = 0
def play_only(): with sd.OutputStream(device=device_name, channels=channels, callback=callback, samplerate=samplerate): print("press return to quit") input()
def audio_sink(sample_seq, fs): q = queue.Queue() def audio_callback(outdata, frames, time, status): if not q.empty(): outdata[:] = q.get_nowait() stream = sounddevice.OutputStream(samplerate=10000, blocksize=3360, dtype="float32", callback=audio_callback, channels=2) # prefill buffer for samples in itertools.islice(sample_seq, 4): ll, ul = np.min(samples), np.max(samples) s = samples * 0.5 / (ul - ll + 1) q.put(s.reshape(-1, 1)) with stream: for samples in sample_seq: if samples is None: break ll, ul = np.min(samples), np.max(samples) s = samples * 0.5 / (ul - ll + 1) q.put(s.reshape(-1, 1))
def denoiser_output(): global LIVE device_out = "Soundflower (2ch)" caps = query_devices(device_out, "output") channels_out = min(caps['max_output_channels'], 1) stream_out = sd.OutputStream(device=None, samplerate=sample_rate, channels=channels_out) stream_out.start() while (1): while (LIVE == 1): if buffer != []: while len(buffer) > 10: del (buffer[0]) frame = buffer[0] del (buffer[0]) # print(len(buffer)) start = time.time() output = omlsa_streamer(frame, sample_rate, frame_length, frame_move, postprocess="butter", high_cut=3000) print(time.time() - start) stream_out.write(output.astype(np.float32)) while (LIVE == 0): if buffer != []: while len(buffer) > 10: del (buffer[0]) frame = buffer[0] del (buffer[0]) stream_out.write(frame) stream_out.stop()
def main(): vocal = Voc(sd.default.samplerate) def process(outdata, frames, time, status): if status: print(status) _osc = 0 _voc = 0 if vocal.counter == 0: _osc = 12 + 16 * (0.5 * (_osc + 1)) vocal.tongue_shape(_osc, 2.9) out = np.array(vocal.compute(), dtype=np.float32)[:CHUNK] print(outdata.shape, out.shape) outdata[:] = out.reshape(-1, 1) with sd.OutputStream(channels=1, callback=process, blocksize=CHUNK, samplerate=sd.default.samplerate) as ostream: print(ostream.cpu_load) sd.sleep(int(duration * 1000)) print(ostream.cpu_load)
def StartSnd(self,serial_event): # open audio thread self.sd1 = sd.OutputStream(dtype='float32',callback=callback,blocksize=256) self.sd1.start() # open serial thread self.tser=threading.Thread(target=self.SerialDect,args=(serial_event,),name='serialdetect') self.tser.start()
def __init__(self, out_fs, out_channel, out_bit_depth, frames_per_buffer, usb_card_keyword): threading.Thread.__init__(self) # 初始化配置 self.daemon = True self.exit_flag = False self.out_fs = out_fs self.out_channels = out_channel self.out_bit_depth = out_bit_depth self.frames_per_buffer = frames_per_buffer params = { "samplerate": out_fs, "device": None, "channels": out_channel, "dtype": np.float32, } # 为当前所有可用输出设备创建输出流 self.devices = OutputDeviceIterable(usb_card_keyword) self.streams = StreamsIterable() for index, info in self.devices: print(index, info["name"]) params["device"] = index self.streams.append(sd.OutputStream(**params)) self.start()
def play_unbuffered(gen, blocksize=1024, samplerate=44100): t = 0 def callback(outdata, frames, time, status): nonlocal t nonlocal gen if status: return for i in range(blocksize): outdata[i, 0] = gen.amp((t + i) / samplerate) t += blocksize try: stream = sd.OutputStream(samplerate=samplerate, blocksize=blocksize, device=sd.default.device, channels=1, dtype='float32', callback=callback) with stream: threading.Event().wait() except KeyboardInterrupt: return except Exception as e: tb.print_exc()
def load(self, sample_rate, dtype, block, channels, callback): self.reset() self.stream = sd.OutputStream(samplerate=sample_rate, blocksize=block, channels=channels, callback=callback, dtype=self.get_dtype_string(dtype))
def __init__(self, pitch=0, pitch_per_second=12, decibels=0, decibels_per_second=1, samplerate=utilities.DEFAULT_SAMPLE_RATE, collect_data=False, silent=False): self.sinewave_generator = sinewave_generator.SineWaveGenerator( pitch=pitch, pitch_per_second=pitch_per_second, decibels=decibels, decibels_per_second=decibels_per_second, samplerate=samplerate) # Create the output stream self.collected_data = np.array([]) self.fs = samplerate self.collect_data = collect_data self.finished = False self.silent = silent self.output_stream = sd.OutputStream( channels=1, callback=lambda *args: self._callback(*args), finished_callback=lambda *args: self._finished_callback(*args), samplerate=samplerate)
def run(self): """ The primary thread function that initializes the OutputStream and continuously calls the Stream listener to place data from the buffer into the Stream Parameters ---------- None Returns ------- None Raises ------ None """ try: logging.debug('Running Output Speaker thread') with self.waitCondition: self.waitCondition.wait() with sd.OutputStream(device=self.device, channels=2, blocksize=self.stepSize, callback=self.listener): while not self.stopped: # time takes up less cpu cycles than 'pass' time.sleep(1) except Exception as e: logging.exception(f'Exception thrown: {e}')
def main(): outdevice = 1 samplerate = 32000 blocksize = 256 source = "172.16.0.29" source = "localhost" import queue OUT = queue.Queue() def callback_out(outdata, frames, time, status): outdata[:] = OUT.get() with sd.OutputStream( samplerate=samplerate, blocksize=blocksize, device=outdevice, channels=1, latency='low', callback=callback_out, ), Receiver(f"tcp://{source}:5555") as stream: audiostream = AudioReceiver(f"tcp://{source}:5556") for streamtype, data in buffer(0.5, { "video": stream.handler, "audio": audiostream.handler }): if streamtype == 'video': display(data['arr']) if streamtype == 'audio': OUT.put(data['arr'])
def set_output_stream(self): """ Opens an output stream with the currently set speaker. Note: The output stream retrieves the speaker device from self.__speaker, which can be set using set_speaker. Example: sound = Sound() sound.set_speaker('USB2.0 Device') sound.set_output_stream() """ try: assert isinstance( self.__speaker, unicode), "Speaker could not be found. Speaker: " + str( self.__speaker) self.__output_stream = sd.OutputStream( samplerate=self.__speaker_sample_rate, device=self.__speaker, channels=1, dtype="float32", ) except AssertionError as e: print(e)
def easy_sound(freq, pos): fbins = [ 1.570, 4.714, 7.862, 11.0186, 14.18624, 33.616, 36.7912, 40.3274, 43.744 ] stream = sd.OutputStream(dtype=np.int16, channels=2) stream.start() time = 2.0 wave = 0 samples = np.arange(44100 * 1 * time) / 44100.0 for i in range(len(fbins)): if (fbins[i] * freq > 20000.0): break a = np.sin(np.pi * (i + 1) * pos / 1.0) / (343 * fbins[i] * freq) alpha = (1 / 4) * 1 * (2 - (np.sin(2 * np.pi * (i + 1)) / (np.pi * (i + 1)))) a /= alpha print(a) wave += a * np.sin(2 * np.pi * (fbins[i] * freq) * samples) wave *= 100000000 for i in range(len(wave)): # print(wave[i]) wave[i] *= np.exp(-2.0 * (i / 44100)) wav_wave = np.array(wave, dtype=np.int16) stream.write(wav_wave) stream.close() scipy.io.wavfile.write('out.wav', 44100, wav_wave) return wav_wave
def run(self): while (True): with sd.OutputStream(channels=1, callback=self.callback, samplerate=self.fs): while (not self.play_stopped): time.sleep(.05)
def __init__(self, angular_accuracy=1, fs=48000): self.distance = angular_accuracy self.angular_accuracy = angular_accuracy # characteristics frequency = 300 # Hz amplitude = 0.1 # mag pulse_duration = 10 # cycles fade_length = 400 # samples self.gap_multi = 10 # angular distance -> gapwidt in ms * gap_multi (1° -> 1ms * gap_multi) # other stuff self.start_idx = 0 self.fs = fs self.pulse = np.array([]) self.stream = sd.OutputStream(samplerate=self.fs, channels=1, callback=self.audio_callback) # precalculate sinepulse T_sine = int(fs / frequency) t = np.arange(T_sine * pulse_duration) self.sine = amplitude * np.sin(2 * np.pi * t / T_sine) fade = np.arange(fade_length) / fade_length self.sine[:fade_length] = self.sine[:fade_length] * fade self.sine[-fade_length:] = self.sine[-fade_length:] * np.flip(fade)
def _check_stream(self, samplerate: float = None, channels: int = None) -> None: """This function is a hack to fix a problem with an sounddevice streams in an unsane state: these streams have both, `active` and `stopped` flag (and also the `closed` flag) set to `False`. Such a state seems to occur when the stream is stopped (or aborted) from within the stream Thread (while stopping or aborting from another Thread seems to be ok). Such unsane streams can not be restarted by calling stream.start(), they seem to be dead (at least I did not find a way to revive them). As a workaround, we simply create a new stream here to replace the original one. """ # Check the state of the current stream if self._stream is not None and not self._stream.closed: if self._stream.active or self._stream.stopped: return # Stream seems to be ok LOG.warning("SoundDevicePlayer: " "discovered unsane stream - creating a new one ...") # Stream seems to be dead - copy stream parameters samplerate = samplerate or self._stream.samplerate channels = channels or self._stream.channels self._stream.close() # create a new stream self._stream = sd.OutputStream(samplerate=samplerate, channels=channels, callback=self._play_block, finished_callback=self._finished)
def __init__(self, sampleRate, channels, blockSize, device=None, duplex=False): # initialise thread self.streams = [] self.list = [] # sound stream info self.sampleRate = sampleRate self.channels = channels self.duplex = duplex self.blockSize = blockSize self.label = getStreamLabel(sampleRate, channels, blockSize) if device == 'default': device = None self.sounds = [] # list of dicts for sounds currently playing self.takeTimeStamp = False self.frameN = 1 # self.frameTimes = range(5) # DEBUGGING: store the last 5 callbacks if not travisCI: # travis-CI testing does not have a sound device self._sdStream = sd.OutputStream(samplerate=self.sampleRate, blocksize=self.blockSize, latency='low', device=device, channels=self.channels, callback=self.callback) self._sdStream.start() self.device = self._sdStream.device self.latency = self._sdStream.latency self.cpu_load = self._sdStream.cpu_load self._tSoundRequestPlay = 0
def start(self): """ Start the playback """ with h5py.File(self._fn, 'r') as f: self._ad = f['audio'] dtype = self._ad.dtype dtype_str = str(dtype) stream = sd.OutputStream(samplerate=self.samplerate, blocksize=self.blocksize, channels=1, dtype=dtype_str, callback=self.audio_callback) self._running <<= True if self._video: self._vd = f['video'] videothread = Thread(target=self.video_thread_fcn) videothread.start() with stream: try: with self._running_cond: while self._running: self._running_cond.wait() except KeyboardInterrupt: print('Keyboard interrupt. Quit playback') if self._video: videothread.join()