def get_Note(self, string=0, fret=0, maxfret=24):
"""Return the Note on 'string', 'fret'.
Throw a RangeError if either the fret or string is unplayable.
Examples:
>>> t = tunings.StringTuning('test', 'test', ['A-3', 'A-4'])
>>> t,get_Note(0, 0)
'A-3'
>>> t.get_Note(0, 1)
'A#-3'
>>> t.get_Note(1, 0)
'A-4'
"""
if 0 <= string < self.count_strings():
if 0 <= fret <= maxfret:
s = self.tuning[string]
if type(s) == list:
s = s[0]
n = Note(int(s) + fret)
n.string = string
n.fret = fret
return n
else:
raise RangeError("Fret '%d' on string '%d' is out of range" % (string, fret))
else:
raise RangeError("String '%d' out of range" % string)
def from_interval_shorthand(self, startnote, shorthand, up=True):
"""Empty the container and add the note described in the startnote and
shorthand.
See core.intervals for the recognized format.
Examples:
>>> nc = NoteContainer()
>>> nc.from_interval_shorthand('C', '5')
['C-4', 'G-4']
>>> nc.from_interval_shorthand('C', '5', False)
['F-3', 'C-4']
"""
self.empty()
if type(startnote) == str:
startnote = Note(startnote)
n = Note(startnote.name, startnote.octave, startnote.dynamics)
n.transpose(shorthand, up)
self.add_notes([startnote, n])
return self
def test_set_note(self):
n = Note()
self.assert_(n.set_note('C', 5, {}))
n.empty()
self.assert_(n.set_note('C-5'))
self.assert_(n.set_note('C', 5))
self.assert_(n.set_note('C#-12', 5))
self.assertRaises(NoteFormatError, n.set_note, 'H')
self.assertRaises(NoteFormatError, n.set_note, 'C 23')
self.assertRaises(NoteFormatError, n.set_note, 'C# 123')
def low_timbale(self):
return Note(66 - 12)
def MIDI_to_Composition(self, file):
(header, track_data) = self.parse_midi_file(file)
c = Composition()
if header[2]["fps"]:
print("Don't know how to parse this yet")
return c
ticks_per_beat = header[2]["ticks_per_beat"]
for track in track_data:
t = Track()
b = Bar()
metronome = 1 # Tick once every quarter note
thirtyseconds = 8 # 8 thirtyseconds in a quarter note
meter = (4, 4)
key = "C"
for e in track:
(deltatime, event) = e
duration = float(deltatime) / (ticks_per_beat * 4.0)
if duration != 0.0:
duration = 1.0 / duration
if len(b.bar) > 0:
current_length = b.bar[-1][1]
b.bar[-1][1] = duration
if current_length - duration != 0:
b.current_beat -= 1.0 / current_length
b.current_beat += 1.0 / duration
if not b.place_notes(NoteContainer(), duration):
t + b
b = Bar(key, meter)
b.place_notes(NoteContainer(), duration)
if event["event"] == 8:
if deltatime == 0:
pass
elif event["event"] == 9:
# note on
n = Note(
notes.int_to_note(event["param1"] % 12),
event["param1"] // 12 - 1,
)
n.channel = event["channel"]
n.velocity = event["param2"]
if len(b.bar) > 0:
b.bar[-1][2] + n
else:
b + n
elif event["event"] == 10:
# note aftertouch
pass
elif event["event"] == 11:
# controller select
pass
elif event["event"] == 12:
# program change
i = MidiInstrument()
i.instrument_nr = event["param1"]
t.instrument = i
elif event["event"] == 0x0F:
# meta event Text
if event["meta_event"] == 1:
pass
elif event["meta_event"] == 3:
# Track name
t.name = event["data"].decode("ascii")
elif event["meta_event"] == 6:
# Marker
pass
elif event["meta_event"] == 7:
# Cue Point
pass
elif event["meta_event"] == 47:
# End of Track
pass
elif event["meta_event"] == 81:
# Set tempo warning Only the last change in bpm will get
# saved currently
mpqn = self.bytes_to_int(event["data"])
bpm = 60000000 // mpqn
elif event["meta_event"] == 88:
# Time Signature
d = event["data"]
thirtyseconds = self.bytes_to_int(d[3])
metronome = self.bytes_to_int(d[2]) / 24.0
denom = 2**self.bytes_to_int(d[1])
numer = self.bytes_to_int(d[0])
meter = (numer, denom)
b.set_meter(meter)
elif event["meta_event"] == 89:
# Key Signature
d = event["data"]
sharps = self.bytes_to_int(d[0])
minor = self.bytes_to_int(d[0])
if minor:
key = "A"
else:
key = "C"
for i in range(abs(sharps)):
if sharps < 0:
key = intervals.major_fourth(key)
else:
key = intervals.major_fifth(key)
b.key = Key(key)
else:
print("Unsupported META event", event["meta_event"])
else:
print("Unsupported MIDI event", event)
t + b
c.tracks.append(t)
return (c, bpm)
def hi_bongo(self):
return Note(60 - 12)
def test_place_notes_types(self):
self.assertEqual(True, self.meterless + NoteContainer(["A", "C"]))
self.assertEqual(True, self.meterless + "A")
self.assertEqual(True, self.meterless + Note("A"))
self.assertEqual(True, self.meterless + ["A", "B"])
self.assertEqual(True, self.meterless + [Note("A"), Note("B")])
def MIDI_to_Composition(self, file):
(header, track_data) = self.parse_midi_file(file)
c = Composition()
if header[2]['fps']:
print "Don't know how to parse this yet"
return c
ticks_per_beat = header[2]['ticks_per_beat']
for track in track_data:
t = Track()
b = Bar()
metronome = 1 # Tick once every quarter note
thirtyseconds = 8 # 8 thirtyseconds in a quarter note
meter = (4, 4)
key = 'C'
for e in track:
(deltatime, event) = e
duration = float(deltatime) / (ticks_per_beat * 4.0)
if duration != 0.0:
duration = 1.0 / duration
if deltatime != 0:
if not b.place_notes(NoteContainer(), duration):
t + b
b = Bar(key, meter)
b.place_notes(NoteContainer(), duration)
if event['event'] == 8:
if deltatime == 0:
pass
elif event['event'] == 9:
# note on
n = Note(notes.int_to_note(event['param1'] % 12),
event['param1'] / 12 - 1)
n.channel = event['channel']
n.velocity = event['param2']
if len(b.bar) > 0:
b.bar[-1][2] + n
else:
b + n
elif event['event'] == 10:
# note aftertouch
pass
elif event['event'] == 11:
# controller select
pass
elif event['event'] == 12:
# program change
i = MidiInstrument()
i.instrument_nr = event['param1']
t.instrument = i
elif event['event'] == 0x0f:
# meta event Text
if event['meta_event'] == 1:
pass
elif event['meta_event'] == 3:
# Track name
t.name = event['data']
elif event['meta_event'] == 6:
# Marker
pass
elif event['meta_event'] == 7:
# Cue Point
pass
elif event['meta_event'] == 47:
# End of Track
pass
elif event['meta_event'] == 81:
# Set tempo warning Only the last change in bpm will get
# saved currently
mpqn = self.bytes_to_int(event['data'])
bpm = 60000000 / mpqn
elif event['meta_event'] == 88:
# Time Signature
d = event['data']
thirtyseconds = self.bytes_to_int(d[3])
metronome = self.bytes_to_int(d[2]) / 24.0
denom = 2 ** self.bytes_to_int(d[1])
numer = self.bytes_to_int(d[0])
meter = (numer, denom)
b.set_meter(meter)
elif event['meta_event'] == 89:
# Key Signature
d = event['data']
sharps = self.bytes_to_int(d[0])
minor = self.bytes_to_int(d[0])
if minor:
key = 'A'
else:
key = 'C'
for i in xrange(abs(sharps)):
if sharps < 0:
key = intervals.major_fourth(key)
else:
key = intervals.major_fifth(key)
b.key = Note(key)
else:
print 'Unsupported META event', event['meta_event']
else:
print 'Unsupported MIDI event', event
t + b
c.tracks.append(t)
return (c, bpm)
def open_cuica(self):
return Note(79 - 12)
def open_triangle(self):
return Note(81 - 12)
def test_transpose(self):
a = Note('C')
a.transpose('3')
self.assertEqual(Note('E'), a)
a.transpose('b2')
self.assertEqual(Note('F'), a)
a.transpose('5')
self.assertEqual(Note('C', 5), a)
a.transpose('5', False)
self.assertEqual(Note('F'), a)
a = Note('G-5')
a.transpose('5')
self.assertEqual(Note('D-6'), a)
a.transpose('5', False)
self.assertEqual(Note('G-5'), a)
a.transpose('5', False)
self.assertEqual(Note('C-5'), a)
def low_wood_block(self):
return Note(77 - 12)
def high_timbale(self):
return Note(65 - 12)
def low_conga(self):
return Note(64 - 12)
def open_hi_conga(self):
return Note(63 - 12)
def mute_hi_conga(self):
return Note(62 - 12)
def low_bongo(self):
return Note(61 - 12)
def ride_cymbal_2(self):
return Note(59 - 12)
def high_agogo(self):
return Note(67 - 12)
def mute_cuica(self):
return Note(78 - 12)
def low_agogo(self):
return Note(68 - 12)
def mute_triangle(self):
return Note(80 - 12)
def cabasa(self):
return Note(69 - 12)
class Piano(Instrument):
name = 'Piano'
range = (Note('F', 0), Note('B', 8))
def __init__(self):
Instrument.__init__(self)
def maracas(self):
return Note(70 - 12)
def test_get_range(self):
self.b + NoteContainer(["C", "E"])
self.assertEqual((Note("C"), Note("E")), self.b.get_range())
def short_whistle(self):
return Note(71 - 12)
def test_getitem(self):
self.assertEqual(self.n2[0], Note("A"))
self.assertEqual(self.n3[0], Note("A"))
self.assertEqual(self.n4[0], Note("A"))
self.assertEqual(self.n4[1], Note("C", 5))
self.assertEqual(self.n4[2], Note("E", 5))
def long_whistle(self):
return Note(72 - 12)
import struct
import numpy
from mingus.containers.note import Note
from numpy.fft import fft as _fft
import operator
# Making a frequency-amplitude table Adapted some ideas and source from:
# http://xoomer.virgilio.it/sam_psy/psych/sound_proc/sound_proc_python.html
#
# The log function turns out to be really, really slow, which adds up quickly.
# So before we do any performance critical calculations we set up a cache of all
# the frequencies we need to look up.
_log_cache = []
for x in range(129):
_log_cache.append(Note().from_int(x).to_hertz())
_last_asked = None
def _find_log_index(f):
"""Look up the index of the frequency f in the frequency table.
Return the nearest index.
"""
global _last_asked, _log_cache
(begin, end) = (0, 128)
# Most calls are sequential, this keeps track of the last value asked for so
# that we need to search much, much less.
if _last_asked is not None:
(lastn, lastval) = _last_asked
def short_guiro(self):
return Note(73 - 12)
def test_from_Note(self):
self.assertEqual(LilyPond.from_Note(Note("C"), standalone=False), "c'")
self.assertEqual(LilyPond.from_Note(Note("C#"), standalone=False), "cis'")
self.assertEqual(LilyPond.from_Note(Note("C##"), standalone=False), "cisis'")
self.assertEqual(LilyPond.from_Note(Note("Cb"), standalone=False), "ces'")
self.assertEqual(LilyPond.from_Note(Note("Cbb"), standalone=False), "ceses'")
self.assertEqual(LilyPond.from_Note(Note("C", 0), standalone=False), "c,,,")
self.assertEqual(LilyPond.from_Note(Note("C", 1), standalone=False), "c,,")
self.assertEqual(LilyPond.from_Note(Note("C", 2), standalone=False), "c,")
self.assertEqual(LilyPond.from_Note(Note("C", 3), standalone=False), "c")
self.assertEqual(LilyPond.from_Note(Note("C", 4), standalone=False), "c'")
self.assertEqual(LilyPond.from_Note(Note("C", 5), standalone=False), "c''")
self.assertEqual(LilyPond.from_Note(Note("C", 6), standalone=False), "c'''")
self.assertEqual(LilyPond.from_Note(Note("C", 7), standalone=False), "c''''")
def long_guiro(self):
return Note(74 - 12)
def test_from_hertz(self):
a = Note()
self.assertEqual(a.from_hertz(55.5), Note('A', 1))
self.assertEqual(a.from_hertz(110), Note('A', 2))
a.from_hertz(220)
self.assertEqual(a, Note('A', 3))
a.from_hertz(440)
self.assertEqual(a, Note('A', 4))
a.from_hertz(880)
self.assertEqual(a, Note('A', 5))
a.from_hertz(1760)
self.assertEqual(a, Note('A', 6))
def claves(self):
return Note(75 - 12)
def hi_wood_block(self):
return Note(76 - 12)
note = "F#"
note_type = 19
if event.unicode == '8':
note = "G#"
note_type = 21
if event.unicode == '9':
note = "A#"
note_type = 23
if args.note:
note_type = int(args.note[0],10)
if note != "" and notes.is_valid_note(note) == False:
print ERROR + "invalid note"
else:
if note == "":
break;
n = Note()
if note == "k":
n.set_Note('B')
else:
if note_type == 0:
n.set_note(note)
else:
n.set_note(note,note_type)
print ACTION + "playing Note : " + note
fluidsynth.play_Note(n)
#saving the play
if args.save:
nc.add_note(n)
if event.unicode == 's':
print ACTION + "saving file .."
