def render_progression(progression, voicing):
global time
for i, p in enumerate(progression):
chord = key_chords[p]
# root, third, fifth = chord.notes
timeline.add(time + i * 2.0 * rhythm_mod,
Hit(chord.notes[voicing[i][0]], 2.0 * rhythm_mod))
timeline.add(time + i * 2.0 * rhythm_mod,
Hit(chord.notes[voicing[i][1]], 2.0 * rhythm_mod))
def render_melody(rhythm, melody):
global time
print("r = " + str(rhythm))
for r, m in zip(rhythm, melody):
# print("len(chords) = %s, m = %s" %(len(key_chords), m))
note = key_chords[m]
timeline.add(time, Hit(note.notes[0], r * 2.0 * rhythm_mod))
time += (r * 2.0 * rhythm_mod)
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...")
data = effect.chorus(data, freq=3.14159)
chords = [[],
[Note("C3"),Note("E3"),Note("G3")],
[Note("D3"),Note("F3"),Note("A3")],
[Note("E3"),Note("G3"),Note("B3")],
[Note("F3"),Note("A3"),Note("C4")],
[Note("G3"),Note("B3"),Note("D4")],
[Note("A3"),Note("C4"),Note("E4")],
[Note("B3"),Note("D4"),Note("F4")],
[Note("C4"),Note("E4"),Note("G4")],
]
bassNote = bassProgression
for x in range(0,8):
timeline.add(x*.5,Hit(bassProgression[x],1))
time = 0.0
def getChord(inputNote):
returnChord = []
print inputNote.note
if inputNote.note == "c":
returnChord = chords[1]
elif inputNote.note == "d":
returnChord = chords[2]
elif inputNote.note == "e":
returnChord = chords[3]
progressions.append(make_progression_part())
voicings.append(make_voicing_part(len(progressions[-1])))
rhythms.append(make_rhythm_part())
melodies.append(make_melody_part(len(rhythms[-1])))
# Render the progressions and melodies in patterns
song_length = randint(2, 3) * complexity // 2
for _ in range(song_length):
i = randint(0, complexity - 1)
render_progression(progressions[i], voicings[i])
j = randint(0, complexity - 1)
render_melody(rhythms[j], melodies[j])
# Strum out root chord to finish
chord = key_chords[0]
timeline.add(time + 0.0, Hit(chord.notes[0], 4.0))
timeline.add(time + 0.1, Hit(chord.notes[1], 4.0))
timeline.add(time + 0.2, Hit(chord.notes[2], 4.0))
timeline.add(time + 0.3, Hit(chord.notes[1].transpose(12), 4.0))
timeline.add(time + 0.4, Hit(chord.notes[2].transpose(12), 4.0))
timeline.add(time + 0.5, Hit(chord.notes[0].transpose(12), 4.0))
print("Rendering audio...")
data = timeline.render()
# Reduce volume to 25%
data = data * 0.25
#print("Playing audio...")
print("Saving audio to " + filepath)
if note.index == "G3":
note = random.choice(G3, A3, F3)
if note.index == "A3":
note = random.choice(A3, B3, G3)
if note.index == "B3":
note = random.choice(B3, C3, A3)
if note.index == "C4":
note = random.choice(B3, C4)
print "Playing audio..."
data = timeline.render()
playback.play(data)
print "Done!"
timeline.add(time, Hit(note, 1))
# Resolve
print "Rendering audio..."
print "Playing audio..."
playback.play(data)
print "Done!"
def add(t, sound):
timeline.add(t, Hit(sound_string[sound], 1, sound))
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
#Populate Timeline
for note in melodyArray:
def main(argv):
try:
opts, args = getopt.getopt(argv, "hdsm", ['help', 'debug', 'startup', 'morning'])
except getopt.GetoptError:
usage()
sys.exit(2)
global _debug
_debug = 0
morning = False
for opt, arg in opts:
if opt in ("-h", "--help"):
usage()
sys.exit()
if opt in ("-m", "--morning"):
morning = True
_debug = 1
if opt == '-d':
_debug = 1
if opt in ("-s", "--startup"):
import time
time.sleep(90)
#os.system("/usr/bin/tvservice -o")
# Increase chance of singing at sunrise/sunset
import ephem
birdcage = ephem.Observer()
birdcage.lat = '51.497517'
birdcage.lon = '0.080380'
birdcage.date = str(datetime.datetime.now())
birdcage.elevation = 5
sun = ephem.Sun()
next_sunrise = birdcage.next_rising(sun)
early_next_sunrise = ephem.Date(next_sunrise - 15 * ephem.minute)
late_next_sunrise = ephem.Date(next_sunrise + 15 * ephem.minute)
next_sunset = birdcage.next_setting(sun)
early_next_sunset = ephem.Date(next_sunset - 15 * ephem.minute)
late_next_sunset = ephem.Date(next_sunset + 15 * ephem.minute)
sunrise = False;
sunset = False;
if (birdcage.date > early_next_sunrise and birdcage.date < late_next_sunrise):
#print 'Sunrise roll'
sunrise = true;
dice_roll = random.choice([1,2,3,4,5,6,7,8])
elif (birdcage.date > early_next_sunset and birdcage.date < late_next_sunset):
#print 'Sunset roll'
sunset = true;
dice_roll = random.choice([1,2,3,4,5,6,7,8])
else:
dice_roll = random.choice([1,2,3,4,5,6])
if (dice_roll < 5 and _debug <> 1):
#print "Going back to sleep"
sys.exit()
# We're alive, import what else we need now
sys.path.append(os.path.join(os.path.dirname(__file__), 'python-musical'))
from musical.theory import Note, Scale, Chord
from musical.audio import effect, playback
from timeline import Hit, Timeline
# Define key and scale
key = Note((random.choice(Note.NOTES), random.choice([2,3,3])))
scales = ['major', 'minor', 'melodicminor', 'harmonicminor', 'pentatonicmajor', 'bluesmajor', 'pentatonicminor', 'bluesminor', 'augmented', 'diminished', 'wholehalf', 'halfwhole', 'augmentedfifth', 'japanese', 'oriental', 'ionian', 'phrygian', 'lydian', 'mixolydian', 'aeolian', 'locrian']
random.shuffle(scales)
scale = Scale(key, random.choice(scales))
#print key
#print scale
# Grab progression chords from scale starting at the octave of our key
progression = Chord.progression(scale, base_octave=key.octave)
time = 0.0 # Keep track of correct note placement time in seconds
timeline = Timeline()
# Pick a notes from a chord randomly chosen from a list of notes in this progression
chord = progression[ random.choice(range(len(progression)-1)) ]
notes = chord.notes
melodies = [
[0.8, 0.2],
[0.4, 0.2],
[0.2, 0.8],
[0.2, 0.4],
[0.6, 0.2],
[0.4, 0.4, 0.2],
[0.6, 0.1, 0.1],
[0.8, 0.1, 0.2],
[0.2, 0.2, 0.2],
[0.2, 0.4, 0.2],
[1.0, 0.1, 0.2, 0.1, 0.2, 0.10, 0.1],
[0.8, 0.4, 0.1, 0.2, 0.4, 0.1, 0.2],
[0.8, 0.4, 0.4, 0.2, 0.2, 0.1, 0.1],
[0.4, 0.0, 0.1, 0.1, 0.2, 0, 0.1, 0.4],
[0.1, 0.1, 0.1, 0.0, 0.2, 0.0, 0.1, 0.2, 0.4],
[0.8, 0.4, 0.1, 0.4, 0.2, 0.2, 0.1, 0.2, 0.8, 0.1, 0.4, 0.1],
[0.2, 0.2, 0.4, 0.2, 0.1, 0.1, 0.0, 0.2],
[1.0, 0.1, 0.2, 0.1, 0.2, 0.2],
[0.2, 0.1, 0.2, 0.4, 0.1, 0.2, 0.4],
[0.4, 0.1, 0.4, 0.2, 0.4, 0.1, 0.4, 0.2],
[0.1, 0.1, 0.1, 0.2, 0.1, 0.1, 0.2],
[0.1, 0.1, 0.1, 0.2, 0.1, 0.1, 0.1, 0.2, 0.0],
[0.1, 0.0, 0.1, 0.0, 0.1, 0.0, 0.2, 0.0, 0.2, 0.0, 0.1, 0.1, 0.3],
]
if sunrise or sunset:
random_melody = random.choice(melodies[0:12])
else:
random_melody = random.choice(melodies)
# Testing a new melody-generation idea - duncan 11/4/20
# - needs more work, disabling for now - 12/4/20
#random_melody = []
#melody_length = random.randrange(1, 12)
#
#for i in range(0, melody_length):
# random_melody.append( round(random.uniform(0.1, 0.6), 1) )
# test end
if morning:
random_melody = melodies[-1]
print random_melody
last_interval = 0.0
last_transpose = 0
for i, interval in enumerate(random_melody):
random_note = random.choice(notes)
# the first note should be high
# identical intervals should often hold the same pitch
# otherwise, pick a random pitch
if i == 0:
random_transpose = random.choice([8, 12])
elif (last_interval == interval):
if random.choice([0,1,2]) == 2:
random_transpose = last_transpose
else:
random_transpose = 0
else:
random_transpose = random.choice([0,2,4,6,8,10,12])
last_interval = interval
last_transpose = random_transpose
note = random_note.transpose(random_transpose)
#print note
# favour queued notes, but occasionally overlap them too
if (random.choice([1,2,3,4,5,6]) > 2):
time = time + interval
timeline.add(time, Hit(note, interval))
else:
timeline.add(time, Hit(note, interval))
time = time + interval
#print "Rendering audio..."
data = timeline.render()
# Reduce volume to 50%
data = data * 0.5
print "Playing audio..."
if morning:
for i in range(2):
playback.play(data)
else:
for i in range(random.choice([1,2])):
playback.play(data)
def make_sound(type): mytimeline = Timeline() mytimeline.add(0, Hit(type, 1, sound_string[type])) data = mytimeline.render() playback.play(data)
def get_timeline_from_hlr(hlr):
timeline = Timeline()
for t, chord, duration in hlr:
for note in chord.notes:
timeline.add(t, Hit(note, duration))
return timeline
textInput = input('please input some text: ')
print('textInput:', textInput)
# encode in a bytearray
textBytes = textInput.encode()
print('textBytes', textBytes)
# hash the text
textHash = hashlib.md5()
textHash.update(textBytes)
digest = textHash.digest()
print('digest:', digest)
# convert bytes to integers
integers = [n for n in digest]
print(integers)
for char in digest:
print(char)
# play the notes
time = 0.0
timeline = Timeline()
for pitch in integers:
print(pitch)
timeline.add(time, Hit(Note(pitch % 32 + 24), 0.6))
time += 0.6
data = timeline.render()
playback.play(data)