class sinePlayer(Thread):
def __init__(self, event):
Thread.__init__(self)
# Define "stop" trigger
self.stopped = event
# Define key
self.key = Note('C3')
# Define scale
self.scale = Scale(self.key, 'harmonic minor')
self.note = self.key
self.chunks = []
self.chunks.append(source.sawtooth(self.note, 0.5))
self.data = numpy.concatenate(self.chunks)
self.data = self.data * 0.5
# Adjust audio by x steps in scale defined above
def adjustAudio(self, adjustment, loudness):
self.note = self.scale.transpose(self.key, adjustment)
self.chunks = []
self.chunks.append(source.sawtooth(self.note, .5))
self.data_adjusted = numpy.concatenate(self.chunks)
self.data_adjusted = self.data_adjusted * 0.5 * loudness
self.data = self.data_adjusted
# Runs indefinitely until passed "stop" trigger
def run(self):
while not self.stopped.wait(0.001):
playback.play(self.data)
def generate_song(
notes_per_chord,
num_repeats,
note_time=0.25,
prog_intervals=(7, 2, -4j, 5)
):
# generate a random major key
root = Note(rand.choice(Note.NOTES))
scale_notes = Scale(root, 'major')
octave = 3
progression = Chord.progression(
Scale(
root,
[int(p.real + p.imag) for p in prog_intervals]
),
octave
)
for i, z in enumerate(prog_intervals):
if z.imag != 0:
# TODO: cannot have a repeated chord be minor
progression[i] = major_to_minor(progression[i])
# generates a melody for the progression
low_octave = 4
prev_note = rand.choice(list(scale_notes)).at_octave(low_octave)
melody = []
for _ in range(notes_per_chord * len(progression) * num_repeats):
note_dist = int(round(rand.gauss(0, 2)))
prev_note = scale_notes.transpose(prev_note, note_dist)
melody.append(prev_note)
# build up the HLR from the melody progression
song = []
t = 0
for i in range(num_repeats):
for chord in progression:
song.append(
(t*note_time, chord, note_time*notes_per_chord)
)
t += notes_per_chord
for i in range(len(melody)):
note = melody[i]
song.append((i*note_time, Chord([note]), note_time))
return song
time = 0.0 # Keep track of currect note placement time in seconds
timeline = Timeline()
note = key
# Semi-randomly queue notes from the scale
for i in range(64):
if note.index > 50 or note.index < 24:
# If note goes out of comfort zone, randomly place back at base octave
note = scale.get(random.randrange(4) * 2)
note = note.at_octave(key.octave)
else:
# Transpose the note by some small random interval
note = scale.transpose(note, random.choice((-2, -1, 1, 2)))
length = random.choice((0.125, 0.125, 0.25))
timeline.add(time, Hit(note, length + 0.125))
time += length
# Resolve
note = scale.transpose(key, random.choice((-1, 1, 4)))
timeline.add(time, Hit(note, 0.75)) # Tension
timeline.add(time + 0.5, Hit(key, 4.0)) # Resolution
print("Rendering audio...")
data = timeline.render()
print("Applying chorus effect...")
fname = "out/%s%d.wav" % (note.note, note.octave)
save.save_wave(data, fname)
return fname
if os.path.exists("out"):
shutil.rmtree("out")
os.mkdir("out")
root = Note(ROOT)
scale = Scale(root, SCALE)
notes = [None] * NUM_NOTES
mid = NUM_NOTES / 2
notes[mid] = root
for i in range(mid):
notes[i] = scale.transpose(root, i - mid)
for i in range(mid + 1, NUM_NOTES):
notes[i] = scale.transpose(root, i - mid)
files = []
for note in notes:
files.append(render_note(note))
#f = open("files.json", "w")
#json.dump(files, f)
#f.close()
import numpy
from musical.theory import Note, Scale
from musical.audio import source, playback
# Define key and scale
key = Note('C4')
scale = Scale(key, 'major')
note = key
chunks = []
for i in xrange(len(scale)):
third = scale.transpose(note, 2)
chunks.append(source.sine(note, 0.5) + source.square(third, 0.5))
note = scale.transpose(note, 1)
fifth = scale.transpose(key, 4)
chunks.append(source.sine(key, 1.5) + source.square(fifth, 1.5))
print "Rendering audio..."
data = numpy.concatenate(chunks)
# Reduce volume to 50%
data = data * 0.5
print "Playing audio..."
playback.play(data)
print "Done!"
import numpy
from musical.theory import Note, Scale
from musical.audio import source, playback
# Define key and scale
key = Note('C4')
scale = Scale(key, 'major')
note = key
chunks = []
for i in xrange(len(scale)):
third = scale.transpose(note, 2)
chunks.append(source.sine(note, 0.5) + source.square(third, 0.5))
note = scale.transpose(note, 1)
fifth = scale.transpose(key, 4)
chunks.append(source.sine(key, 1.5) + source.square(fifth, 1.5))
print "Rendering audio..."
data = numpy.concatenate(chunks)
# Reduce volume to 50%
data = data * 0.5
print "Playing audio..."
playback.play(data)
print "Done!"
elif inputNote.note == "a":
noteBelow = "g%i" % (inputNote.octave)
noteAbove = "b%i" % (inputNote.octave)
else:
noteBelow = "a%i" % (inputNote.octave)
noteAbove = "c%i" % (inputNote.octave + 1)
return(random.choice([Note(noteBelow),Note(noteAbove)]))
for w in range(0,22):
if w == 0:
melodyArray = []
bassArray = []
bassArray.append(Note("C2"))
melodyArray.append(Note(scale.transpose(bassArray[0],9)))
if (w % 2 == 0):
timeline.add((w/2)*.5,Hit(bassArray[w/2],1))
bassNote = bassArray[w/2]
#Define Melody Array
bassArray.append(nextBassNote(bassArray[w/2-1]))
melodyArray.append(nextNote(melodyArray[w-1],bassArray[w%2]))
time = 0.0 # Keep track of currect note placement time in seconds
timeline = Timeline()
note = key
# Semi-randomly queue notes from the scale
for i in xrange(64):
if note.index > 50 or note.index < 24:
# If note goes out of comfort zone, randomly place back at base octave
note = scale.get(random.randrange(4) * 2)
note = note.at_octave(key.octave)
else:
# Transpose the note by some small random interval
note = scale.transpose(note, random.choice((-2, -1, 1, 2)))
length = random.choice((0.125, 0.125, 0.25))
timeline.add(time, Hit(note, length + 0.125))
time += length
# Resolve
note = scale.transpose(key, random.choice((-1, 1, 4)))
timeline.add(time, Hit(note, 0.75)) # Tension
timeline.add(time + 0.5, Hit(key, 4.0)) # Resolution
print "Rendering audio..."
data = timeline.render()
print "Applying chorus effect..."
