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 .."