def m21_to_stream(score,
synth=ks_synth,
beat=90,
fdur=2.,
pad_dur=.5,
rate=lz.DEFAULT_SAMPLE_RATE):
"""
Converts Music21 data to a Stream object.
Parameters
----------
score :
A Music21 data, usually a music21.stream.Score instance.
synth :
A function that receives a frequency as input and should yield a Stream
instance with the note being played.
beat :
The BPM (beats per minute) value to be used in playing.
fdur :
Relative duration of a fermata. For example, 1.0 ignores the fermata, and
2.0 (default) doubles its duration.
pad_dur :
Duration in seconds, but not multiplied by ``s``, to be used as a
zero-padding ending event (avoids clicks at the end when playing).
rate :
The sample rate, given in samples per second.
"""
# Configuration
s, Hz = lz.sHz(rate)
step = 60. / beat * s
# Creates a score from the music21 data
score = reduce(
operator.concat,
[
[
(
pitch.frequency * Hz, # Note
note.offset * step, # Starting time
note.quarterLength * step, # Duration
Fermata in note.expressions) for pitch in note.pitches
] for note in score.flat.notes
])
# Mix all notes into song
song = lz.Streamix()
last_start = 0
for freq, start, dur, has_fermata in score:
delta = start - last_start
if has_fermata:
delta *= 2
song.add(delta, synth(freq).limit(dur))
last_start = start
# Zero-padding and finishing
song.add(dur + pad_dur * s, lz.Stream([]))
return song
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)
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 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 m21_to_stream(score, synth=ks_synth, beat=90, fdur=2., pad_dur=.5,
rate=lz.DEFAULT_SAMPLE_RATE):
"""
Converts Music21 data to a Stream object.
Parameters
----------
score :
A Music21 data, usually a music21.stream.Score instance.
synth :
A function that receives a frequency as input and should yield a Stream
instance with the note being played.
beat :
The BPM (beats per minute) value to be used in playing.
fdur :
Relative duration of a fermata. For example, 1.0 ignores the fermata, and
2.0 (default) doubles its duration.
pad_dur :
Duration in seconds, but not multiplied by ``s``, to be used as a
zero-padding ending event (avoids clicks at the end when playing).
rate :
The sample rate, given in samples per second.
"""
# Configuration
s, Hz = lz.sHz(rate)
step = 60. / beat * s
# Creates a score from the music21 data
score = reduce(operator.concat,
[[(pitch.frequency * Hz, # Note
note.offset * step, # Starting time
note.quarterLength * step, # Duration
Fermata in note.expressions) for pitch in note.pitches]
for note in score.flat.notes]
)
# Mix all notes into song
song = lz.Streamix()
last_start = 0
for freq, start, dur, has_fermata in score:
delta = start - last_start
if has_fermata:
delta *= 2
song.add(delta, synth(freq).limit(dur))
last_start = start
# Zero-padding and finishing
song.add(dur + pad_dur * s, lz.Stream([]))
return song
def test_empty(self):
ns = run_source("", "named.py")
assert ns["__file__"] == "named.py"
# Some few "global" values that might be used by the plugin
for k in ["rate", "s", "Hz", "ms", "kHz"]:
assert k in ns
assert isinstance(ns[k], int if k == "rate" else float)
# Ensure AudioLazy was imported
for k in audiolazy.__all__:
assert ns[k] is getattr(audiolazy, k)
s, Hz = audiolazy.sHz(1)
assert ns["rate"] == 1
assert ns["s"] == s
assert ns["Hz"] == Hz
assert ns["ms"] == 1e-3 * s
assert ns["kHz"] == 1e3 * Hz
# 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/>.
"""
Gammatone frequency and impulse response plots example
"""
from __future__ import division
from audiolazy import erb, gammatone, gammatone_erb_constants, sHz, impulse, dB20
from numpy import linspace, ceil
from matplotlib import pyplot as plt
# Initialization info
rate = 44100
s, Hz = sHz(rate)
ms = 1e-3 * s
plot_freq_time = {80.0: 60 * ms, 100.0: 50 * ms, 200.0: 40 * ms, 500.0: 25 * ms, 800.0: 20 * ms, 1000.0: 15 * ms}
freq = linspace(0.1, 2 * max(freq for freq in plot_freq_time), 100)
fig1 = plt.figure("Frequency response", figsize=(16, 9), dpi=60)
fig2 = plt.figure("Impulse response", figsize=(16, 9), dpi=60)
# Plotting loop
for idx, (fc, endtime) in enumerate(sorted(plot_freq_time.items()), 1):
# Configuration for the given frequency
num_samples = int(round(endtime))
time_scale = linspace(0, num_samples / ms, num_samples)
bw = gammatone_erb_constants(4)[0] * erb(fc * Hz, Hz)
# Subplot configuration
Call with the API name like ...
./animated_plot.py jack
... or without nothing for the default PortAudio API.
"""
from __future__ import division
from audiolazy import sHz, chunks, AudioIO, line, pi, window
from matplotlib import pyplot as plt
from matplotlib.animation import FuncAnimation
from numpy.fft import rfft
import numpy as np
import collections, sys, threading
# AudioLazy init
rate = 44100
s, Hz = sHz(rate)
ms = 1e-3 * s
length = 2**12
data = collections.deque([0.] * length, maxlen=length)
wnd = np.array(window.hamming(length)) # For FFT
api = sys.argv[1] if sys.argv[1:] else None # Choose API via command-line
chunks.size = 1 if api == "jack" else 16
# Creates a data updater callback
def update_data():
with AudioIO(api=api) as rec:
for el in rec.record(rate=rate):
data.append(el)
# The GUI in this example is based on the dose TDD semaphore source code
# https://github.com/danilobellini/dose
import wx
from math import pi
from audiolazy import (ControlStream, modulo_counter, AudioIO, sHz, sinusoid)
MIN_WIDTH = 15 # pixels
MIN_HEIGHT = 15
FIRST_WIDTH = 200
FIRST_HEIGHT = 200
MOUSE_TIMER_WATCH = 50 # ms
DRAW_TIMER = 50
s, Hz = sHz(44100)
class McFMFrame(wx.Frame):
def __init__(self, parent):
frame_style = (
wx.FRAME_SHAPED | # Allows wx.SetShape
wx.FRAME_NO_TASKBAR | wx.STAY_ON_TOP | wx.NO_BORDER)
super(McFMFrame, self).__init__(parent, style=frame_style)
self.Bind(wx.EVT_ERASE_BACKGROUND, lambda evt: None)
self._paint_width, self._paint_height = 0, 0 # Ensure update_sizes at
# first on_paint
self.ClientSize = (FIRST_WIDTH, FIRST_HEIGHT)
self.Bind(wx.EVT_PAINT, self.on_paint)
self._draw_timer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.on_draw_timer, self._draw_timer)
# The GUI in this example is based on the dose TDD semaphore source code
# https://github.com/danilobellini/dose
import wx
from math import pi
from audiolazy import (ControlStream, modulo_counter,
AudioIO, sHz, sinusoid)
MIN_WIDTH = 15 # pixels
MIN_HEIGHT = 15
FIRST_WIDTH = 200
FIRST_HEIGHT = 200
MOUSE_TIMER_WATCH = 50 # ms
DRAW_TIMER = 50
s, Hz = sHz(44100)
class McFMFrame(wx.Frame):
def __init__(self, parent):
frame_style = (wx.FRAME_SHAPED | # Allows wx.SetShape
wx.FRAME_NO_TASKBAR |
wx.STAY_ON_TOP |
wx.NO_BORDER
)
super(McFMFrame, self).__init__(parent, style=frame_style)
self.Bind(wx.EVT_ERASE_BACKGROUND, lambda evt: None)
self._paint_width, self._paint_height = 0, 0 # Ensure update_sizes at
# first on_paint
self.ClientSize = (FIRST_WIDTH, FIRST_HEIGHT)
self.Bind(wx.EVT_PAINT, self.on_paint)
3rd -> drone Bravo, direction east, distance 1m
Tonic -> drone Charlie, direction south, distance 2m
Tonic -> drone Delta, direction west, distance 4m
Some parts of this file were adapted from the AudioLazy example "animated_plot.py".
"""
from __future__ import division
from audiolazy import sHz, chunks, AudioIO, line, pi, window
import numpy as np
import collections, sys, threading, time
import rospy
from std_msgs.msg import String
# static configurations
rate = 44100
s, Hz = sHz(rate) # s = rate, Hz = tau / rate
length = 2**14
noteNames = ["tonic", "3rd", "5th", "octave"]
relativeNotes = np.log([1, 5 / 4, 3 / 2, 2])
#api = sys.argv[1] if sys.argv[1:] else None # Choose API via command-line
api = None
chunks.size = 1 if api == "jack" else 16
class WhitleDetector(object):
def __init__(self):
# Allocating Data
self.data = collections.deque([0.] * length, maxlen=length)
self.wnd = np.array(window.hamming(length)) # For FFT
# TODO: Maybe break into an object
self.lastWhistleTime = None
"""
Musical Mines - A minesweeper game to help learning musical skills.
"""
from _mmines.core import GameGrid
from _mmines import (MIN_TILE_SIZE, PI, DEFAULT_GRID_SIZES, DSIZE, DCOLOR,
NCOLOR)
import wx
import audiolazy as lz
import random
__version__ = "0.1"
__author__ = "Danilo de Jesus da Silva Bellini"
rate = 44100
s, Hz = lz.sHz(rate)
ms = 1e-3 * s
SYNTH_ADSR_PARAMS = dict(a=40*ms, d=20*ms, s=.7, r=50*ms)
SYNTH_DURATION = .4 * s
SYNTH_ENVELOPE = list(lz.adsr(SYNTH_DURATION, **SYNTH_ADSR_PARAMS) * .55)
SYNTH_PAUSE_AT_END = lz.zeroes(.25 * s).take(lz.inf)
synth_table = lz.sin_table.harmonize(dict(enumerate(
[.1, .15, .08, .05, .04, .03, .02]
)))
class GameScreenArea(wx.Panel):
def __init__(self, parent, rows, cols, nmines, *args, **kwargs):
super(GameScreenArea, self).__init__(parent, *args, **kwargs)
self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM) # Avoids flicker
plt.xlabel('frequency [Hz]')
plt.ylabel('power [dB]')
plt.title('background noise, spectra averaged')
plt.gca().xaxis.set_major_locator( plt.MaxNLocator(nbins = 10) )
plt.savefig('backgroundnoise_subglottalresonance.pdf', orientation = 'landscape', bbox_inches = 'tight')
# <codecell>
import audiolazy as lz
# <codecell>
s, Hz = lz.sHz(fs)
print "s: {}, Hz: {}".format(s, Hz)
# <codecell>
Hz == (2 * lz.pi / fs)
# <codecell>
print "Nfft: {}, overlap: {}, hop: {}".format(Nfft, overlap, hop)
stream_chest = lz.Stream(chest).blocks(size = Nfft, hop = hop)
stream_falsetto = lz.Stream(falsetto).blocks(size = Nfft, hop = hop)
stream_background = lz.Stream(background).blocks(size = Nfft, hop = hop)
