def update_data(self): with AudioIO(api=api) as rec: for el in rec.record( rate=rate): # Appears to run at about 44100 hz self.data.append(el) if self.finishedUpdate: break
def __init__(self, lista_filtros, ncanais=1,rate=44100): """ Inicia o Player. lista_filtros: lista de filtros aplicados, se for uma tupla, se trata de uma preset. pos: Posição Inicial no preset """ self.filtros = lista_filtros if self.filtros is not None: self.filter = CascadeFilter(self.filtros) else: self.filter = CascadeFilter() self.ncanais = ncanais self.release = 0.05*filters.s self.rate = rate self.player = AudioIO() self.streamix = Streamix(True) self.input = ChangeableStream(self.player.record(nchannels=ncanais,rate=self.rate)) self.input.last = 0. self.stream = ChangeableStream(self.filter(self.input)) self.stream.last = 0. self.player.play(self.streamix, rate=self.rate) self.streamix.add(0,self.stream)
def pitch_from_mic(upd_time_in_ms): rate = 44100 s, Hz = sHz(rate) with AudioIO() as recorder: snd = recorder.record(rate=rate) sndlow = lowpass(400 * Hz)(limiter(snd, cutoff=20 * Hz)) hop = int(upd_time_in_ms * 1e-3 * s) for pitch in freq2str(dft_pitch(sndlow, size=2 * hop, hop=hop) / Hz): yield pitch
def pitch_from_mic(upd_time_in_ms): rate = 44100 s, Hz = sHz(rate) api = sys.argv[1] if sys.argv[1:] else None # Choose API via command-line chunks.size = 1 if api == "jack" else 16 with AudioIO(api=api) as recorder: snd = recorder.record(rate=rate) sndlow = lowpass(400 * Hz)(limiter(snd, cutoff=20 * Hz)) hop = int(upd_time_in_ms * 1e-3 * s) for pitch in freq2str(dft_pitch(sndlow, size=2 * hop, hop=hop) / Hz): yield pitch
def update_data(): with AudioIO(api=api) as rec: for el in rec.record(rate=rate): data.append(el) if update_data.finish: break
a1 = Stream(*cycle_a1) a2 = Stream(*cycle_a2) * 2 b1 = sinusoid(18 * Hz) # Sine phase b2 = sinusoid(freq=7 * Hz, phase=pi / 2) # Cosine phase # The filter filt = (1 + b1 * z**-1 + b2 * z**-2 + .7 * z**-5) filt /= (1 - a1 * z**-1 - a2 * z**-2 - .1 * z**-3) # A really simple input input_data = sinusoid(220 * Hz) # Let's play it! api = sys.argv[1] if sys.argv[1:] else None # Choose API via command-line chunks.size = 1 if api == "jack" else 16 with AudioIO(api=api) as player: th = player.play(input_data, rate=rate) time.sleep(1) # Wait a sec th.stop() time.sleep(1) # One sec "paused" player.play(filt(input_data), rate=rate) # It's nice with rate/2 here =) time.sleep(3) # Play the "filtered" input (3 secs) # Quiz! # # Question 1: What's the filter "cycle" duration? # Hint: Who cares? # # Question 2: Does the filter need to be periodic? # Hint: Import white_noise and try to put this before defining the filt: # a1 *= white_noise()
"ɤ": [460, 1310], "o": [360, 640], "ɯ": [300, 1390], "u": [250, 595], } # Initialization rate = 44100 s, Hz = sHz(rate) inertia_dur = 1 * s inertia_filter = maverage(rint(inertia_dur)) api = sys.argv[1] if sys.argv[1:] else None # Choose API via command-line chunks.size = 1 if api == "jack" else 16 with AudioIO() as player: first_coeffs = formants[vowels[0]] # These are signals to be changed during the synthesis f1 = ControlStream(first_coeffs[0] * Hz) f2 = ControlStream(first_coeffs[1] * Hz) gain = ControlStream(0) # For fading in # Creates the playing signal filt = CascadeFilter([ resonator.z_exp(inertia_filter(f1).skip(inertia_dur), 400 * Hz), resonator.z_exp(inertia_filter(f2).skip(inertia_dur), 2000 * Hz), ]) sig = filt((saw_table)(100 * Hz)) * inertia_filter(gain) th = player.play(sig)
#!/usr/bin/env python # -*- coding: utf-8 -*- # This file is part of AudioLazy, the signal processing Python package. # Copyright (C) 2012-2013 Danilo de Jesus da Silva Bellini # # AudioLazy is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, version 3 of the License. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # # Created on Wed Nov 07 2012 # danilo [dot] bellini [at] gmail [dot] com """ Simple I/O wire example, connecting the input directly to the output """ from audiolazy import AudioIO with AudioIO(True) as player_recorder: input_data = player_recorder.record(chunk_size=16) player_recorder.play(input_data, chunk_size=16)
octave_duration = duration / noctaves smix = Streamix() data = [] # Global: keeps one parcial "track" for all uses (but the first) # Inits "data" def partial(): smix.add(octave_duration, partial_cached()) # Next track/partial event # Octave-based frequency values sequence scale = 2**line(duration, finish=True) partial_freq = (scale - 1) * (max_freq - min_freq) + min_freq # Envelope to "hide" the partial beginning/ending env = [k**2 for k in window.hamming(int(round(duration)))] # The generator, properly: for el in env * sinusoid(partial_freq) / noctaves: data.append(el) yield el # Replicator ("track" data generator) def partial_cached(): smix.add(octave_duration, partial_cached()) # Next track/partial event for el in data: yield el # Play! smix.add(0, partial()) # Starts the mixing with the first track/partial with AudioIO(True) as player: player.play(smix, rate=rate)
# GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. """ Simple I/O wire example, connecting the input directly to the output This example uses the default PortAudio API, however you can change it by using the "api" keyword argument in AudioIO creation, like with AudioIO(True, api="jack") as pr: obviously, you can use another API instead (like "alsa"). Note ---- When using JACK, keep chunks.size = 1 """ from audiolazy import chunks, AudioIO import sys # Choose API via command-line api = sys.argv[1] if sys.argv[1:] else None # Amount of samples per chunk to be sent to PortAudio chunks.size = 1 if api == "jack" else 16 with AudioIO(True, api=api) as pr: # A player-recorder pr.play(pr.record())
# This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # # Created on Wed Nov 07 2012 # danilo [dot] bellini [at] gmail [dot] com """ Simple I/O wire example, connecting the input directly to the output This example uses the default PortAudio API, however you can change it by using the "api" keyword argument in AudioIO creation, like with AudioIO(True, api="jack") as pr: obviously, you can use another API instead (like "alsa"). Note ---- When using JACK, keep chunks.size = 1 """ from audiolazy import chunks, AudioIO chunks.size = 16 # Amount of samples per chunk to be sent to PortAudio with AudioIO(True) as pr: # A player-recorder pr.play(pr.record())
class Player: """ Classe Player, gerencia um player de Audio. É destruído no STOP. Ao pausar apenas para de exibir novos valores """ def __init__(self, lista_filtros, ncanais=1,rate=44100): """ Inicia o Player. lista_filtros: lista de filtros aplicados, se for uma tupla, se trata de uma preset. pos: Posição Inicial no preset """ self.filtros = lista_filtros if self.filtros is not None: self.filter = CascadeFilter(self.filtros) else: self.filter = CascadeFilter() self.ncanais = ncanais self.release = 0.05*filters.s self.rate = rate self.player = AudioIO() self.streamix = Streamix(True) self.input = ChangeableStream(self.player.record(nchannels=ncanais,rate=self.rate)) self.input.last = 0. self.stream = ChangeableStream(self.filter(self.input)) self.stream.last = 0. self.player.play(self.streamix, rate=self.rate) self.streamix.add(0,self.stream) def last_input_output(self): """ Função que retorna os últimos valores de input e output Na forma de tupla (in,out) """ try: return (self.input.last, self.stream.last) except: return (0,0) def muda_filtro(self, novos_filtros, window): """ Muda o filtro aplicado, garantindo que não haja um "click" ao fazer isso """ #self.chamando = True novo_filtro = CascadeFilter(novos_filtros) last = self.stream.last self.stream.limit(0).append(line(self.release,last,0)) self.stream = ChangeableStream(novo_filtro(self.input)) self.stream.last = last self.streamix.add(0, self.stream) def __del__(self): if not self.player.finished: self.player.close() #self.playerGrava.close() def pausar (self): """ Para o player """ if not self.player.finished: self.player.close() def tocar (self, lista_filtros=None): """ Reinicia o player (tanto quando ele é pausado como parado) """ if lista_filtros is None: lista_filtros = self.filtros self.__init__(lista_filtros,ncanais=self.ncanais,rate=self.rate)
data = [] # Global: keeps one parcial "track" for all uses (but the first) # Inits "data" def partial(): smix.add(octave_duration, partial_cached()) # Next track/partial event # Octave-based frequency values sequence scale = 2**line(duration, finish=True) partial_freq = (scale - 1) * (max_freq - min_freq) + min_freq # Envelope to "hide" the partial beginning/ending env = [k**2 for k in window.hamming(int(round(duration)))] # The generator, properly: for el in env * sinusoid(partial_freq) / noctaves: data.append(el) yield el # Replicator ("track" data generator) def partial_cached(): smix.add(octave_duration, partial_cached()) # Next track/partial event for el in data: yield el # Play! smix.add(0, partial()) # Starts the mixing with the first track/partial api = sys.argv[1] if sys.argv[1:] else None # Choose API via command-line chunks.size = 1 if api == "jack" else 16 with AudioIO(True, api=api) as player: player.play(smix, rate=rate)
# it under the terms of the GNU General Public License as published by # the Free Software Foundation, version 3 of the License. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. """ Realtime STFT effect to robotize a voice (or anything else) This is done by removing (zeroing) the phases, which means a single spectrum block processing function that keeps the magnitudes and removes the phase, a function a.k.a. "abs", the absolute value. The initial zero-phasing isn't needed at all since the phases are going to be removed, so the "before" step can be safely removed. """ from audiolazy import window, stft, chunks, AudioIO import sys wnd = window.hann robotize = stft(abs, size=1024, hop=441, before=None, wnd=wnd, ola_wnd=wnd) api = sys.argv[1] if sys.argv[1:] else None chunks.size = 1 if api == "jack" else 16 with AudioIO(True, api=api) as pr: pr.play(robotize(pr.record()))