def play_music(self, x, y):
'''
Generate sounds from data to be used for each coordinate.
x and y are the coordinates of any image point.
'''
scale = build_scale('C', mode='major', octaves=1)
notes = note_number(self.data, scale)
note = notes[y,x]
melody = parse(note_name(note, scale))
midi_out = StringIO()
write('Oc.midi', [melody])
os.system('fluidsynth --audio-driver=alsa /usr/share/sounds/sf2/FluidR3_GM.sf2 Oc.midi')
def play_music(self, x, y):
'''
Generate sounds from data to be used for each coordinate.
x and y are the coordinates of any image point.
'''
scale = build_scale('C', mode='major', octaves=1)
notes = note_number(self.data, scale)
note = notes[y,x]
melody = parse(note_name(note, scale))
midi_out = StringIO()
write('Oc.midi', [melody])
pygame.mixer.init()
music = pygame.mixer.Sound('Oc.midi')
pygame.mixer.music.load('Oc.midi')
pygame.mixer.music.play()
def test_write_midi(self):
"""
Writing out test.mid to ensure midi processing works.
This isn't really a test.
"""
from sebastian.core import OSequence, Point
from sebastian.core import OFFSET_64, MIDI_PITCH, DURATION_64
test = OSequence([
Point({OFFSET_64: o, MIDI_PITCH: m, DURATION_64: d}) for (o, m, d) in [
(0, 60, 16), (16, 72, 16), (32, 64, 16), (48, 55, 16),
(64, 74, 16), (80, 62, 16), (96, 50, 16), (112, 48, 16),
(128, 36, 16), (144, 24, 16), (160, 40, 16), (176, 55, 16),
(192, 26, 16), (208, 38, 16), (224, 50, 16), (240, 48, 16)
]
])
from sebastian.midi.write_midi import write
write("test.mid", [test])
def test_write_midi_multi_tacks(self):
"""
Writing out test.mid to ensure midi processing works.
This isn't really a test.
"""
from sebastian.core import OSequence, Point
from sebastian.core import OFFSET_64, MIDI_PITCH, DURATION_64
test1 = OSequence([
Point({OFFSET_64: o, MIDI_PITCH: m, DURATION_64: d}) for (o, m, d) in [
(0, 60, 16), (16, 72, 16), (32, 64, 16), (48, 55, 16),
]
])
test2 = OSequence([
Point({OFFSET_64: o, MIDI_PITCH: m, DURATION_64: d}) for (o, m, d) in [
(0, 55, 16), (16, 55, 16), (32, 64, 16), (48+16, 55, 16*10),
]
])
from sebastian.midi.write_midi import write
write("test2.mid", [test1, test2], instruments=[0,16], title="test song")
# Create the basic interval pattern.
intervals = HSeq({DEGREE: x} for x in [1, 5, 1, 4, 1, 5, 1])
# Create the rhythm
rhythm = HSeq({DURATION_64: x} for x in [128, 64, 64, 64, 64, 64, 64])
# Set specific chords to be used in certain measures.
intervals[1]["chord"] = (-3, -1, 0, 2) # second inversion 7th
intervals[3]["chord"] = (-3, 0, 2) # second inversion
intervals[5]["chord"] = (-5, -3, 0) # first inversion
# Combine the sequences, make them chords, produce alberti on the chords,
# fill with each being 8, expand it to a flat sequence.
melody = intervals & rhythm | chord() | alberti | fill(8) | expand
# Define our key
C_major = Key("C", major_scale)
#key(major_scale(-2))
# Set the degree, add the midi pitch, make it an OSequence, add debugging information.
return melody | degree_in_key_with_octave(C_major, 5) | midi_pitch() | OSequence | debug
if __name__ == "__main__":
movement = build_movement()
for point in movement:
pprint(point)
write_midi.write("first_movement.mid", [movement])
from sebastian.lilypond import write_lilypond
# construct sequences using lilypond syntax
melody = parse("e4 e f g g f e d c c d e")
A = parse("e4. d8 d2")
Aprime = parse("d4. c8 c2")
two_bars = melody + A + melody + Aprime
two_bars = two_bars | midi_to_pitch()
two_bars = two_bars | add({"octave": 5})
velocities = [
"pppppp", "ppppp", "pppp", "ppp", "pp", "p", "mp", "mf", "f", "ff", "fff",
"ffff"
]
for d in velocities:
two_bars_with_dynamics = two_bars | dynamics(d)
write_midi.write("ode_%s.mid" % (d, ), [two_bars_with_dynamics])
two_bars_ff_lily = two_bars | dynamics("ff") | lilypond()
write_lilypond.write("ode_ff.ly", two_bars_ff_lily)
crescendo = two_bars | dynamics("ppp", "ff")
write_midi.write("ode_crescendo.mid", [crescendo])
write_lilypond.write("ode_crescendo.ly", crescendo | lilypond())
diminuendo = two_bars | dynamics("mf", "pppp")
write_midi.write("ode_diminuendo.mid", [diminuendo])
write_lilypond.write("ode_diminuendo.ly", diminuendo | lilypond())
from sebastian.lilypond.interp import parse
from sebastian.core.transforms import dynamics, lilypond, midi_to_pitch, add
from sebastian.midi import write_midi
from sebastian.lilypond import write_lilypond
# construct sequences using lilypond syntax
melody = parse("e4 e f g g f e d c c d e")
A = parse("e4. d8 d2")
Aprime = parse("d4. c8 c2")
two_bars = melody + A + melody + Aprime
two_bars = two_bars | midi_to_pitch()
two_bars = two_bars | add({"octave": 5})
velocities = ["pppppp", "ppppp", "pppp", "ppp", "pp", "p", "mp", "mf", "f", "ff", "fff", "ffff"]
for d in velocities:
two_bars_with_dynamics = two_bars | dynamics(d)
write_midi.write("ode_%s.mid" % (d,), [two_bars_with_dynamics])
two_bars_ff_lily = two_bars | dynamics("ff") | lilypond()
write_lilypond.write("ode_ff.ly", two_bars_ff_lily)
crescendo = two_bars | dynamics("ppp", "ff")
write_midi.write("ode_crescendo.mid", [crescendo])
write_lilypond.write("ode_crescendo.ly", crescendo | lilypond())
diminuendo = two_bars | dynamics("mf", "pppp")
write_midi.write("ode_diminuendo.mid", [diminuendo])
write_lilypond.write("ode_diminuendo.ly", diminuendo | lilypond())
def end(scale):
return HSeq(scale[i] for i in [2, 1]) | add(quaver_point)
def h2(scale):
return HSeq(scale[i] for i in [0, 4, 3, 4]) | add(quaver_point)
def h2_end1(scale):
return HSeq(scale[i] for i in [0, 4]) | add(quaver_point)
# there's two important quarter notes used at the ends of sections
e1 = HSeq(scale[3]) | add(quarter_point)
e2 = HSeq(scale[0]) | add(quarter_point)
partA = h1(scale) + h1_end1(scale) + e1 + h1(scale) + end(scale) + e2
partB = h2(scale) + h2_end1(scale) + e1 + h2(scale) + end(scale) + e2
# here we see the basic structure of the song
oseq = OSequence((partA * 2) + (partB * 2))
C_major = Key("C", major_scale)
# note values filled-out for C major in octave 5 then MIDI pitches calculated
seq = oseq | degree_in_key_with_octave(C_major, 5) | midi_pitch()
# write to file:
write_midi.write("shortning_bread_1.mid", [seq])
"""
The main title theme to HBO's Game of Thrones by Ramin Djawadi
"""
from sebastian.core import Point, HSeq, OSequence
from sebastian.core.transforms import midi_pitch, degree_in_key, add
from sebastian.core.notes import Key, major_scale, minor_scale
from sebastian.midi import write_midi
C_Major = Key("C", major_scale)
C_minor = Key("C", minor_scale)
motive_degrees = HSeq(Point(degree=n) for n in [5, 1, 3, 4])
motive_rhythm_1 = HSeq(Point(duration_64=n) for n in [16, 16, 8, 8])
motive_rhythm_2 = HSeq(Point(duration_64=n) for n in [48, 48, 8, 8, 32, 32, 8, 8])
motive_1 = motive_degrees & motive_rhythm_1
motive_2 = (motive_degrees * 2) & motive_rhythm_2
# add key and octave
seq1 = (motive_1 * 4) | add({"octave": 5}) | degree_in_key(C_minor)
seq2 = (motive_1 * 4) | add({"octave": 5}) | degree_in_key(C_Major)
seq3 = motive_2 | add({"octave": 4}) | degree_in_key(C_minor)
seq = (seq1 + seq2 + seq3) | midi_pitch() | OSequence
write_midi.write("game_of_thrones.mid", [seq], instruments=[49], tempo=350000)
seq2 = parse("e f g")
# concatenate
seq3 = seq1 + seq2
# transpose and reverse
seq4 = seq3 | transpose(12) | reverse()
# merge
seq5 = seq3 // seq4
# play MIDI
player.play([seq5])
# write to MIDI
write_midi.write("seq5.mid", [seq5])
# contruct a horizontal sequence of scale degrees
seq6 = HSeq(Point(degree=degree) for degree in [1, 2, 3, 2, 1])
# put that sequence into C major, octave 4 quavers
C_MAJOR = Key("C", major_scale)
seq7 = seq6 | add({"octave": 4, DURATION_64: 8}) | degree_in_key(C_MAJOR)
# convert to MIDI pitch and play
player.play([OSequence(seq7 | midi_pitch())])
# sequence of first four degree of a scale
seq8 = HSeq(Point(degree=n) for n in [1, 2, 3, 4])
# add duration and octave
seq2 = parse("e f g")
# concatenate
seq3 = seq1 + seq2
# transpose and reverse
seq4 = seq3 | transpose(12) | reverse()
# merge
seq5 = seq3 // seq4
# play MIDI
player.play([seq5])
# write to MIDI
write_midi.write("seq5.mid", [seq5])
# contruct a horizontal sequence of scale degrees
seq6 = HSeq(Point(degree=degree) for degree in [1, 2, 3, 2, 1])
# put that sequence into C major, octave 4 quavers
C_MAJOR = Key("C", major_scale)
seq7 = seq6 | add({"octave": 4, DURATION_64: 8}) | degree_in_key(C_MAJOR)
# convert to MIDI pitch and play
player.play([OSequence(seq7 | midi_pitch())])
# sequence of first four degree of a scale
seq8 = HSeq(Point(degree=n) for n in [1, 2, 3, 4])
"""
The main title theme to HBO's Game of Thrones by Ramin Djawadi
"""
from sebastian.core import Point, HSeq, OSequence
from sebastian.core.transforms import midi_pitch, degree_in_key, add
from sebastian.core.notes import Key, major_scale, minor_scale
from sebastian.midi import write_midi
C_Major = Key("C", major_scale)
C_minor = Key("C", minor_scale)
motive_degrees = HSeq(Point(degree=n) for n in [5, 1, 3, 4])
motive_rhythm_1 = HSeq(Point(duration_64=n) for n in [16, 16, 8, 8])
motive_rhythm_2 = HSeq(
Point(duration_64=n) for n in [48, 48, 8, 8, 32, 32, 8, 8])
motive_1 = motive_degrees & motive_rhythm_1
motive_2 = (motive_degrees * 2) & motive_rhythm_2
# add key and octave
seq1 = (motive_1 * 4) | add({"octave": 5}) | degree_in_key(C_minor)
seq2 = (motive_1 * 4) | add({"octave": 5}) | degree_in_key(C_Major)
seq3 = motive_2 | add({"octave": 4}) | degree_in_key(C_minor)
seq = (seq1 + seq2 + seq3) | midi_pitch() | OSequence
write_midi.write("game_of_thrones.mid", [seq], instruments=[49], tempo=350000)
# Create the basic interval pattern.
intervals = HSeq({DEGREE: x} for x in [1, 5, 1, 4, 1, 5, 1])
# Create the rhythm
rhythm = HSeq({DURATION_64: x} for x in [128, 64, 64, 64, 64, 64, 64])
# Set specific chords to be used in certain measures.
intervals[1]["chord"] = (-3, -1, 0, 2) # second inversion 7th
intervals[3]["chord"] = (-3, 0, 2) # second inversion
intervals[5]["chord"] = (-5, -3, 0) # first inversion
# Combine the sequences, make them chords, produce alberti on the chords,
# fill with each being 8, expand it to a flat sequence.
melody = intervals & rhythm | chord() | alberti | fill(8) | expand
# Define our key
C_major = Key("C", major_scale)
#key(major_scale(-2))
# Set the degree, add the midi pitch, make it an OSequence, add debugging information.
return melody | degree_in_key_with_octave(C_major, 5) | midi_pitch() | OSequence | debug
if __name__ == "__main__":
movement = build_movement()
for point in movement:
pprint(point)
write_midi.write("first_movement.mid", [movement])
from sebastian.core.transforms import midi_pitch, degree_in_key_with_octave, add
from sebastian.core.notes import Key, major_scale
from sebastian.midi import write_midi
def alberti(triad):
"""
takes a VSeq of 3 notes and returns an HSeq of those notes in an
alberti figuration.
"""
return HSeq(triad[i] for i in [0, 2, 1, 2])
# an abstract VSeq of 3 notes in root position (degree 1, 3 and 5)
root_triad = VSeq(Point(degree=n) for n in [1, 3, 5])
quaver_point = Point({DURATION_64: 8})
# an OSequence with alberti figuration repeated 16 times using quavers
alberti_osequence = OSequence(alberti(root_triad) * 16 | add(quaver_point))
C_major = Key("C", major_scale)
# note values filled-out for C major in octave 5 then MIDI pitches calculated
seq = alberti_osequence | degree_in_key_with_octave(C_major, 5) | midi_pitch()
# write to file:
write_midi.write("alberti.mid", [seq])
#!/usr/bin/env python
from sebastian.lilypond.interp import parse
from sebastian.midi import write_midi
# construct sequences using lilypond syntax
seq1 = parse("e4. d c r")
seq2 = parse("g4. f4 f8 e4.")
seq2a = parse("r4.")
seq2b = parse("r4 g8")
seq3 = parse("c'4 c'8 b a b c'4 g8 g4")
seq3a = parse("g8")
seq3b = parse("f8")
# concatenate
mice = (seq1 * 2) + (seq2 + seq2a) + (seq2 + seq2b) + (
(seq3 + seq3a) * 2) + (seq3 + seq3b) + seq1
# write to MIDI
write_midi.write("mice.mid", [mice])
from sebastian.core import VSeq, HSeq, Point, OSequence
from sebastian.core.transforms import midi_pitch, degree_in_key_with_octave, add
from sebastian.core.notes import Key, major_scale
from sebastian.midi import write_midi
def alberti(triad):
"""
takes a VSeq of 3 notes and returns an HSeq of those notes in an
alberti figuration.
"""
return HSeq(triad[i] for i in [0, 2, 1, 2])
# an abstract VSeq of 3 notes in root position (degree 1, 3 and 5)
root_triad = VSeq(Point(degree=n) for n in [1, 3, 5])
quaver_point = Point({DURATION_64: 8})
# an OSequence with alberti figuration repeated 16 times using quavers
alberti_osequence = OSequence(alberti(root_triad) * 16 | add(quaver_point))
C_major = Key("C", major_scale)
# note values filled-out for C major in octave 5 then MIDI pitches calculated
seq = alberti_osequence | degree_in_key_with_octave(C_major, 5) | midi_pitch()
# write to file:
write_midi.write("alberti.mid", [seq])
