def mashability(song1, song2):
"""
Returns how well song1 transitions into song2 using cosine matrix similarity
and FFT semitone bin approximation matrices
"""
# If the tempo differs by more than thirty then we should never make that transition
if abs(song1.bpm - song2.bpm) > 30:
return 1
sample_length = MIX_LENGTH #beats per sample
beats1 = song1.AudioFile.analysis.beats[song1.mix_out:song1.mix_out +
sample_length]
beats2 = song2.AudioFile.analysis.beats[song1.mix_in:song1.mix_in +
sample_length]
data1 = audio.getpieces(song1.AudioFile, beats1)
data2 = audio.getpieces(song2.AudioFile, beats2)
data1.encode("temp1.mp3")
data2.encode("temp2.mp3")
y1, sr1 = librosa.load("temp1.mp3")
y2, sr2 = librosa.load("temp2.mp3")
S1 = np.abs(librosa.stft(y1, n_fft=4096))
chroma1 = librosa.feature.chroma_stft(S=S1, sr=sr1)
S2 = np.abs(librosa.stft(y2, n_fft=4096))
chroma2 = librosa.feature.chroma_stft(S=S2, sr=sr2)
# im = librosa.display.specshow(chroma1,x_axis = "time",y_axis = "chroma")
# im2 = librosa.display.specshow(chroma2,x_axis = "time",y_axis = "chroma")
# plt.show()
orthogonal_arr = []
for i in range(min(chroma1.shape[1], chroma2.shape[1])):
orthogonal_arr.append(dst.cosine(chroma1[:, i], chroma2[:, i]))
return sum(orthogonal_arr) / len(orthogonal_arr)
def renderList(songList, outFile):
"""
Takes a list of songs and outputs them to outFile
Has to beatmatch and cross fade
Assumes songList >= 2
"""
mixOutSeg = None
currAudio = None
prevSong = None
for i in range(len(songList)):
currSong = songList[i]
currBeats = currSong.AudioFile.analysis.beats
# This happens on the first iteration, nothing to mix in so just play until mix out
if not mixOutSeg:
currAudio = audio.getpieces(currSong.AudioFile, currBeats[currSong.mix_in : currSong.mix_out])
else:
mixInSeg = currBeats[currSong.mix_in : currSong.mix_in + MIX_LENGTH]
transitionSeg = makeTransition(mixInSeg, mixOutSeg, currSong, prevSong)
transitionSeg.encode("outfiles/transition.mp3")
mainSeg = audio.getpieces(currSong.AudioFile, currBeats[currSong.mix_in + MIX_LENGTH : currSong.mix_out])
currAudio = audio.assemble([currAudio, transitionSeg, mainSeg])
mixOutSeg = currBeats[currSong.mix_out : currSong.mix_out + MIX_LENGTH]
prevSong = currSong
# currAudio = audio.assemble([currAudio, mixOutSeg])
currAudio.encode(outFile)
def mashability(song1, song2):
"""
Returns how well song1 transitions into song2 using cosine matrix similarity
and FFT semitone bin approximation matrices
"""
# If the tempo differs by more than thirty then we should never make that transition
if abs(song1.bpm - song2.bpm) > 30:
return 1
sample_length = MIX_LENGTH # beats per sample
beats1 = song1.AudioFile.analysis.beats[song1.mix_out : song1.mix_out + sample_length]
beats2 = song2.AudioFile.analysis.beats[song1.mix_in : song1.mix_in + sample_length]
data1 = audio.getpieces(song1.AudioFile, beats1)
data2 = audio.getpieces(song2.AudioFile, beats2)
data1.encode("temp1.mp3")
data2.encode("temp2.mp3")
y1, sr1 = librosa.load("temp1.mp3")
y2, sr2 = librosa.load("temp2.mp3")
S1 = np.abs(librosa.stft(y1, n_fft=4096))
chroma1 = librosa.feature.chroma_stft(S=S1, sr=sr1)
S2 = np.abs(librosa.stft(y2, n_fft=4096))
chroma2 = librosa.feature.chroma_stft(S=S2, sr=sr2)
# im = librosa.display.specshow(chroma1,x_axis = "time",y_axis = "chroma")
# im2 = librosa.display.specshow(chroma2,x_axis = "time",y_axis = "chroma")
# plt.show()
orthogonal_arr = []
for i in range(min(chroma1.shape[1], chroma2.shape[1])):
orthogonal_arr.append(dst.cosine(chroma1[:, i], chroma2[:, i]))
return sum(orthogonal_arr) / len(orthogonal_arr)
def renderList(songList, outFile):
"""
Takes a list of songs and outputs them to outFile
Has to beatmatch and cross fade
Assumes songList >= 2
"""
mixOutSeg = None
currAudio = None
prevSong = None
for i in range(len(songList)):
currSong = songList[i]
currBeats = currSong.AudioFile.analysis.beats
# This happens on the first iteration, nothing to mix in so just play until mix out
if not mixOutSeg:
currAudio = audio.getpieces(
currSong.AudioFile,
currBeats[currSong.mix_in:currSong.mix_out])
else:
mixInSeg = currBeats[currSong.mix_in:currSong.mix_in + MIX_LENGTH]
transitionSeg = makeTransition(mixInSeg, mixOutSeg, currSong,
prevSong)
transitionSeg.encode("outfiles/transition.mp3")
mainSeg = audio.getpieces(
currSong.AudioFile,
currBeats[currSong.mix_in + MIX_LENGTH:currSong.mix_out])
currAudio = audio.assemble([currAudio, transitionSeg, mainSeg])
mixOutSeg = currBeats[currSong.mix_out:currSong.mix_out + MIX_LENGTH]
prevSong = currSong
# currAudio = audio.assemble([currAudio, mixOutSeg])
currAudio.encode(outFile)
def write_sample(self, path, prefix):
suffix = 0
if self.samples is not None:
for sample in self.samples:
audio.getpieces(self.audio_file, [sample]).encode(path+prefix+str(suffix)+".wav")
suffix += 1
else:
print "Analyze first"
def makeTransition(inData, outData, inSong, outSong):
"""
Takes two arrays of AudioQuantum objects and returns a single AudioData object
with a linear crossfade and a beatmatch
"""
# The number of beats has to be the same
assert (len(inData) == len(outData))
# If the tempos are the same then it is easy
if inSong.bpm == outSong.bpm:
mixInSeg = audio.getpieces(inSong.AudioFile, inData)
mixOutSeg = audio.getpieces(outSong.AudioFile, outData)
# mixInSeg.encode("outfiles/Mixinseg.mp3")
# mixOutSeg.encode("outfiles/MixOutseg.mp3")
transition_length = 60.0 / 128.0 * MIX_LENGTH
transitionSeg = action.Crossfade([mixOutSeg, mixInSeg], [0.0, 0.0],
transition_length,
mode="linear").render()
return transitionSeg
# Else we iterate over each one
else:
transitionTime = 0
tempoDiff = inSong.bpm - outSong.bpm
marginalInc = float(tempoDiff) / float(MIX_LENGTH)
inCollect = []
outCollect = []
# Rather than a linear slowdown, it is a step function where each beat slows down by marginalInc
for i in range(MIX_LENGTH):
inAudio = inData[i].render()
outAudio = outData[i].render()
# We scale the in and out beats so that they are at the same temp
inScaled = dirac.timeScale(
inAudio.data, inSong.bpm / (outSong.bpm + i * marginalInc))
outScaled = dirac.timeScale(
outAudio.data, outSong.bpm / (outSong.bpm + i * marginalInc))
transitionTime += 60 / (outSong.bpm + i * marginalInc)
ts = audio.AudioData(ndarray=inScaled,
shape=inScaled.shape,
sampleRate=inSong.AudioFile.sampleRate,
numChannels=inScaled.shape[1])
ts2 = audio.AudioData(ndarray=outScaled,
shape=outScaled.shape,
sampleRate=outSong.AudioFile.sampleRate,
numChannels=outScaled.shape[1])
inCollect.append(ts)
outCollect.append(ts2)
# Collect the audio and crossfade it
mixInSeg = audio.assemble(inCollect, numChannels=2)
mixOutSeg = audio.assemble(outCollect, numChannels=2)
# mixInSeg.encode("outfiles/Mixinseg.mp3")
# mixOutSeg.encode("outfiles/MixOutseg.mp3")
transitionSeg = action.Crossfade([mixOutSeg, mixInSeg], [0.0, 0.0],
transitionTime,
mode="exponential").render()
return transitionSeg
def __init__(self, mp3):
self.mp3 = mp3
self.audio_file = audio.LocalAudioFile(self.mp3)
self.analysis = self.audio_file.analysis
self.beats = self.analysis.beats
self.beats.reverse()
#print self.audio_file.analysis.id
print audio
audio.getpieces(self.audio_file, self.beats).encode("remix.mp3")
def write_sample(self, path, prefix):
suffix = 0
if self.samples is not None:
for sample in self.samples:
audio.getpieces(self.audio_file,
[sample]).encode(path + prefix + str(suffix) +
".wav")
suffix += 1
else:
print "Analyze first"
def makeTransition(inData, outData, inSong, outSong):
"""
Takes two arrays of AudioQuantum objects and returns a single AudioData object
with a linear crossfade and a beatmatch
"""
# The number of beats has to be the same
assert len(inData) == len(outData)
# If the tempos are the same then it is easy
if inSong.bpm == outSong.bpm:
mixInSeg = audio.getpieces(inSong.AudioFile, inData)
mixOutSeg = audio.getpieces(outSong.AudioFile, outData)
# mixInSeg.encode("outfiles/Mixinseg.mp3")
# mixOutSeg.encode("outfiles/MixOutseg.mp3")
transition_length = 60.0 / 128.0 * MIX_LENGTH
transitionSeg = action.Crossfade([mixOutSeg, mixInSeg], [0.0, 0.0], transition_length, mode="linear").render()
return transitionSeg
# Else we iterate over each one
else:
transitionTime = 0
tempoDiff = inSong.bpm - outSong.bpm
marginalInc = float(tempoDiff) / float(MIX_LENGTH)
inCollect = []
outCollect = []
# Rather than a linear slowdown, it is a step function where each beat slows down by marginalInc
for i in range(MIX_LENGTH):
inAudio = inData[i].render()
outAudio = outData[i].render()
# We scale the in and out beats so that they are at the same temp
inScaled = dirac.timeScale(inAudio.data, inSong.bpm / (outSong.bpm + i * marginalInc))
outScaled = dirac.timeScale(outAudio.data, outSong.bpm / (outSong.bpm + i * marginalInc))
transitionTime += 60 / (outSong.bpm + i * marginalInc)
ts = audio.AudioData(
ndarray=inScaled,
shape=inScaled.shape,
sampleRate=inSong.AudioFile.sampleRate,
numChannels=inScaled.shape[1],
)
ts2 = audio.AudioData(
ndarray=outScaled,
shape=outScaled.shape,
sampleRate=outSong.AudioFile.sampleRate,
numChannels=outScaled.shape[1],
)
inCollect.append(ts)
outCollect.append(ts2)
# Collect the audio and crossfade it
mixInSeg = audio.assemble(inCollect, numChannels=2)
mixOutSeg = audio.assemble(outCollect, numChannels=2)
# mixInSeg.encode("outfiles/Mixinseg.mp3")
# mixOutSeg.encode("outfiles/MixOutseg.mp3")
transitionSeg = action.Crossfade([mixOutSeg, mixInSeg], [0.0, 0.0], transitionTime, mode="exponential").render()
return transitionSeg
def main(units, key, input_filename, output_filename):
audiofile = audio.LocalAudioFile(input_filename)
chunks = audiofile.analysis.__getattribute__(units)
# Define the sorting function
if key == "duration":
def sorting_function(chunk):
return chunk.duration
if key == "confidence":
def sorting_function(chunk):
if units != "segments":
return chunk.confidence
else:
# Segments have no confidence, so we grab confidence from the tatum
return chunk.tatum.confidence
if key == "loudness":
def sorting_function(chunk):
return chunk.mean_loudness()
sorted_chunks = sorted(chunks, key=sorting_function, reverse=reverse)
out = audio.getpieces(audiofile, sorted_chunks)
out.encode(output_filename)
def main(units, inputFile, outputFile):
audiofile = audio.LocalAudioFile(inputFile)
tonic = audiofile.analysis.key['value']
chunks = audiofile.analysis.__getattribute__(units)
# Get the segments
all_segments = audiofile.analysis.segments
# Find tonic segments
tonic_segments = audio.AudioQuantumList(kind="segment")
for segment in all_segments:
pitches = segment.pitches
if pitches.index(max(pitches)) == tonic:
tonic_segments.append(segment)
# Find each chunk that matches each segment
out_chunks = audio.AudioQuantumList(kind=units)
for chunk in chunks:
for segment in tonic_segments:
if chunk.start >= segment.start and segment.end >= chunk.start:
out_chunks.append(chunk)
break
out = audio.getpieces(audiofile, out_chunks)
out.encode(outputFile)
def main(units, inputFile, outputFile):
audiofile = audio.LocalAudioFile(inputFile)
tonic = audiofile.analysis.key['value']
chunks = audiofile.analysis.__getattribute__(units)
# Get the segments
all_segments = audiofile.analysis.segments
# Find tonic segments
tonic_segments = audio.AudioQuantumList(kind="segment")
for segment in all_segments:
pitches = segment.pitches
if pitches.index(max(pitches)) == tonic:
tonic_segments.append(segment)
# Find each chunk that matches each segment
out_chunks = audio.AudioQuantumList(kind=units)
for chunk in chunks:
for segment in tonic_segments:
if chunk.start >= segment.start and segment.end >= chunk.start:
out_chunks.append(chunk)
break
out = audio.getpieces(audiofile, out_chunks)
out.encode(outputFile)
def mixSample(path1, path2):
audio_file1 = audio.LocalAudioFile(path1)
audio_file2 = audio.LocalAudioFile(path2)
branches = twoSamples(audio_file1, audio_file2, threshold = 250)
# get the beats of interest
branch, collect = [], []
for each in branches:
branch.append(each)
#branch.append(branches[each][0])
# beats re-ordered for rendering
for each in branch:
collect.append(beats[each])
out = audio.getpieces(audio_file1, collect)
name1 = path1.split('/')
name2 = path2.split('/')
output_file = "./mixed/" + name1[len(name1)-1].split('.')[0] + "_" + name2[len(name2)-1].split('.')[0]+ "_out.mp3"
out.encode(output_file)
return
def main(units, key, input_filename, output_filename):
audiofile = audio.LocalAudioFile(input_filename)
chunks = audiofile.analysis.__getattribute__(units)
# Define the sorting function
if key == 'duration':
def sorting_function(chunk):
return chunk.duration
if key == 'confidence':
def sorting_function(chunk):
if units != 'segments':
return chunk.confidence
else:
# Segments have no confidence, so we grab confidence from the tatum
return chunk.tatum.confidence
if key == 'loudness':
def sorting_function(chunk):
return chunk.mean_loudness()
sorted_chunks = sorted(chunks, key=sorting_function, reverse=reverse)
out = audio.getpieces(audiofile, sorted_chunks)
out.encode(output_filename)
def upload():
if request.method == 'POST':
#Get the file
audiofile = request.files['audio']
fname = 'tmp/' + str(long(time.time())) + secure_filename(audiofile.filename)
audiofile.save(fname)
remixfile = audio.LocalAudioFile(fname)
beats = remixfile.analysis.beats
#https://github.com/echonest/remix/blob/master/examples/sorting/sorting.py
def sorting_function(chunk):
return chunk.mean_loudness()
sortedbeats = sorted(beats, key=sorting_function)
out = audio.getpieces(remixfile, sortedbeats)
audioname = str(long(time.time())) + 'sorted' + secure_filename(audiofile.filename) + '.mp3'
outfname = 'tmp/' + audioname
out.encode(outfname, mp3=True)
#Upload to rackspace
chksum = pyrax.utils.get_checksum(outfname)
cf.upload_file("beatsorter", outfname, etag=chksum)
#os.remove(fname)
#os.remove(outfname)
return redirect(url_for('getaudiofile', filename=audioname))
def main(input_filename, output_filename):
audiofile = audio.LocalAudioFile(input_filename)
bars = audiofile.analysis.bars
collect = audio.AudioQuantumList()
for bar in bars:
collect.append(bar.children()[0])
out = audio.getpieces(audiofile, collect)
out.encode(output_filename)
def reverse_audio(self, input_filename, output_filename):
"""
description:
A method that quasi-reverses an audio file by splitting it at each beat and playing the
pieces in reverse.
inputs:
-- str input_filename -- The name of the input audio file.
-- str output_filename -- The name of the audio file to be outputted.
return info:
-- return type -- void
"""
audio_file = self.extractor.get_audio_file(input_filename)
beats = audio_file.analysis.beats
beats.reverse()
audio.getpieces(audio_file, beats).encode(self.audio_files_dir + '/' + output_filename)
def main(input_filename):
audiofile = audio.LocalAudioFile(input_filename)
if granularity == "segment":
all_audio = audiofile.analysis.segments
elif granularity == "tatum":
all_audio = audiofile.analysis.tatums
elif granularity == "beat":
all_audio = audiofile.analysis.beats
elif granularity == "bar":
all_audio = audiofile.analysis.bars
all_segments = audiofile.analysis.segments
output_text_filename = "%ss%s" % (granularity, ".timbre")
f = open(output_text_filename, 'w')
counter = 0
for chunk in all_audio:
output_filename = "%s_%s.wav" % (granularity, counter)
counter = counter + 1
collect = audio.AudioQuantumList()
collect.append(chunk)
out = audio.getpieces(audiofile, collect)
out.encode(output_filename)
# Now I need to write things
# I am going to take timbre values 1 through 7, as 0 is just amplitude.
temp_timbre = []
if granularity == "segment":
temp_timbre = [chunk.timbre[1:7]] # This is needed to make things work with the numpy array stuff
# Work out how to get averages here
# There must be a better way to get segments from an audioQuanta...
if granularity != "segment":
for segment in all_segments:
if segment.start >= chunk.start and segment.start < chunk.get_end():
temp_timbre.append(segment.timbre[1:7])
elif segment.start > chunk.get_end():
break
# This is if we have no segments that starts in the chunk
if not temp_timbre:
for segment in all_segments:
if segment.start < chunk.start and segment.end > chunk.get_end():
temp_timbre.append(segment.timbre[1:7])
break
temp_timbre = numpy.array(temp_timbre)
if temp_timbre.size == 0:
temp_timbre = numpy.array([[0, 0, 0, 0, 0, 0]])
timbre_list = list(temp_timbre.mean(axis=0))
timbre_list = [str(math.floor(t)) for t in timbre_list]
# Yes, I am writing one number per line. Shhh. ChucK's string reading abilities are awful
for timbre in timbre_list:
f.write("%s\n" % timbre)
f.close()
def reverse_audio(self, input_filename, output_filename):
"""
description:
A method that quasi-reverses an audio file by splitting it at each beat and playing the
pieces in reverse.
inputs:
-- str input_filename -- The name of the input audio file.
-- str output_filename -- The name of the audio file to be outputted.
return info:
-- return type -- void
"""
audio_file = self.extractor.get_audio_file(input_filename)
beats = audio_file.analysis.beats
beats.reverse()
audio.getpieces(audio_file, beats).encode(self.audio_files_dir + '/' +
output_filename)
def _write_output_file(self, section_list, output_file):
if section_list:
collect = audio.AudioQuantumList()
for s in section_list:
collect.append(self.sections[s])
else:
collect = self.collect
out = audio.getpieces(self.audiofile, collect)
out.encode(output_file)
def reverse(sInputFileName):
sOutputFileName = 'music/reversed.' + sInputFileName[:-3] + '.wav'
audioFile = audio.LocalAudioFile(sInputFileName)
sToReverse = 'segments'
if sToReverse == 'beats' :
chunks = audioFile.analysis.beats
elif sToReverse == 'segments' :
chunks = audioFile.analysis.segments
chunks.reverse()
reversedAudio = audio.getpieces(audioFile, chunks)
reversedAudio.encode(sOutputFileName)
def main(toReverse, inputFilename, outputFilename):
audioFile = audio.LocalAudioFile(inputFilename)
if toReverse == 'beats' :
chunks = audioFile.analysis.beats
elif toReverse == 'segments' :
chunks = audioFile.analysis.segments
else :
print usage
return
chunks.reverse()
reversedAudio = audio.getpieces(audioFile, chunks)
reversedAudio.encode(outputFilename)
def main(toReverse, inputFilename, outputFilename):
audioFile = audio.LocalAudioFile(inputFilename)
if toReverse == 'beats':
chunks = audioFile.analysis.beats
elif toReverse == 'segments':
chunks = audioFile.analysis.segments
else:
print usage
return
chunks.reverse()
reversedAudio = audio.getpieces(audioFile, chunks)
reversedAudio.encode(outputFilename)
def main(input_filename, output_filename, index):
audio_file = audio.LocalAudioFile(input_filename)
beats = audio_file.analysis.beats
collect = audio.AudioQuantumList()
for beat in beats:
tata = beat.children()
if len(tata)>1:
tat = tata[index]
else:
tat = tata[0]
collect.append(tat)
out = audio.getpieces(audio_file, collect)
out.encode(output_filename)
def main(units, key, input_filename, output_filename):
audiofile = audio.LocalAudioFile(input_filename)
chunks = audiofile.analysis.__getattribute__(units)
key = int(key)
def sorting_function(chunk):
pitches = chunk.mean_pitches()
return pitches.index(max(pitches)) - key % 12
sorted_chunks = sorted(chunks, key=sorting_function, reverse=reverse)
out = audio.getpieces(audiofile, sorted_chunks)
out.encode(output_filename)
def main(units, key, input_filename, output_filename):
audiofile = audio.LocalAudioFile(input_filename)
chunks = audiofile.analysis.__getattribute__(units)
key = int(key)
def sorting_function(chunk):
pitches = chunk.mean_pitches()
return pitches.index(max(pitches)) - key % 12
sorted_chunks = sorted(chunks, key=sorting_function, reverse=reverse)
out = audio.getpieces(audiofile, sorted_chunks)
out.encode(output_filename)
def make_song_snippet(beat1_index, beat2_index, laf1, laf2):
beats1 = laf1.analysis.beats
beats2 = laf2.analysis.beats
bars1 = laf1.analysis.bars
bars2 = laf2.analysis.bars
md51 = laf1.analysis.pyechonest_track.md5
md52 = laf2.analysis.pyechonest_track.md5
distance = bd.get_beat_distance(beats1[beat1_index], beats2[beat2_index])
bar1 = beats1[beat1_index].parent().absolute_context()[0]
bar2 = beats2[beat2_index].parent().absolute_context()[0]
if bar1 - 2 >= 0:
starting_beat = bars1[bar1 - 2].children()[0].absolute_context()[0]
else:
starting_beat = 0
if bar2 + 3 < len(bars2):
last_beat = bars2[bar2 + 3].children()[0].absolute_context()[0]
else:
last_beat = len(beats2)
out = audio.getpieces(beats1.get_source(), beats1[starting_beat:beat1_index])
out += audio.getpieces(beats2.get_source(), beats2[beat2_index:last_beat])
out.encode(OUTPUT_DIR + str(md51) + "_beat_" + str(beat1_index) + "_" + str(md52) +
"_beat_" + str(beat2_index) + "_" + str(distance) + ".wav")
def main(units, key, value, input_filename, output_filename):
audiofile = audio.LocalAudioFile(input_filename)
chunks = audiofile.analysis.__getattribute__(units)
if key == "pitch":
value = int(value)
if key == "pitches":
value = eval(value)
if type(value) != list:
print usage
sys.exit(-1)
if key == "duration":
value = eval(value)
duration_start = value[0]
duration_end = value[1]
if key == "louder" or key == "softer":
value = float(value)
filtered_chunks = []
for chunk in chunks:
if key == "pitch":
pitches = chunk.mean_pitches()
if pitches.index(max(pitches)) == value:
filtered_chunks.append(chunk)
if key == "pitches":
max_indexes = []
pitches = chunk.mean_pitches()
max_pitches = sorted(pitches, reverse=True)
for pitch in max_pitches:
max_indexes.append(pitches.index(pitch))
if set(value) == set(max_indexes[0 : len(value)]):
filtered_chunks.append(chunk)
if key == "duration":
if chunk.start < duration_end and chunk.end > duration_start:
filtered_chunks.append(chunk)
elif chunk.start > duration_end:
break
if key == "louder":
if chunk.mean_loudness() > value:
filtered_chunks.append(chunk)
if key == "softer":
if chunk.mean_loudness() < value:
filtered_chunks.append(chunk)
out = audio.getpieces(audiofile, filtered_chunks)
out.encode(output_filename)
def main(units, key, value, input_filename, output_filename):
audiofile = audio.LocalAudioFile(input_filename)
chunks = audiofile.analysis.__getattribute__(units)
if key == 'pitch':
value = int(value);
if key == 'pitches':
value = eval(value)
if type(value) != list:
print usage
sys.exit(-1)
if key == 'duration':
value = eval(value)
duration_start = value[0]
duration_end = value[1]
if key == 'louder' or key == 'softer':
value = float(value)
filtered_chunks = []
for chunk in chunks:
if key == 'pitch':
pitches = chunk.mean_pitches()
if pitches.index(max(pitches)) == value:
filtered_chunks.append(chunk)
if key == 'pitches':
max_indexes = []
pitches = chunk.mean_pitches()
max_pitches = sorted(pitches, reverse=True)
for pitch in max_pitches:
max_indexes.append(pitches.index(pitch))
if set(value) == set(max_indexes[0:len(value)]):
filtered_chunks.append(chunk)
if key == 'duration':
if chunk.start < duration_end and chunk.end > duration_start:
filtered_chunks.append(chunk)
elif chunk.start > duration_end:
break
if key == 'louder':
if chunk.mean_loudness() > value:
filtered_chunks.append(chunk)
if key == 'softer':
if chunk.mean_loudness() < value:
filtered_chunks.append(chunk)
out = audio.getpieces(audiofile, filtered_chunks)
out.encode(output_filename)
def main(input_filename, output_filename):
# Returns results of the input track.
audiofile = audio.LocalAudioFile(input_filename)
# Gets a list of every section in the track.
sections = audiofile.analysis.sections
# New list for AudioQuantums.
collect = audio.AudioQuantumList()
# Loops through the first item in the children of each section into the new list.
for sec in sections:
collect.append(sec.children()[0])
# Audio defined in collect from analyzed audio file.
out = audio.getpieces(audiofile, collect)
# Writes the new audio.
out.encode(output_filename)
def main(units, timbre_bin, input_filename, output_filename):
audiofile = audio.LocalAudioFile(input_filename)
chunks = audiofile.analysis.__getattribute__(units)
timbre_bin = int(timbre_bin)
# For any chunk, return the timbre value of the given bin
def sorting_function(chunk):
timbre = chunk.mean_timbre()
return timbre[timbre_bin]
sorted_chunks = sorted(chunks, key=sorting_function, reverse=reverse)
out = audio.getpieces(audiofile, sorted_chunks)
out.encode(output_filename)
def main(input_filename, output_filename):
# load audio file
audiofile = audio.LocalAudioFile(input_filename)
# get the beats (Audio Quanta)
beats = audiofile.analysis.beats
# create a new empty list of Audio Quanta
collect = audio.AudioQuantumList()
# add the first segment in each beat in sequence
for beat in beats:
# beat.children are the segments in this beat
# beat.children()[0] is the first segment
collect.append(beat.children()[0])
# Get the raw audio data for the audio quanta and store them in 'out'
out = audio.getpieces(audiofile, collect)
# encode the raw audio as the appropriate file type (using en-ffmpeg)
out.encode(output_filename)
def main(input_filename, output_filename):
# load audio file
audiofile = audio.LocalAudioFile(input_filename)
# get the beats (Audio Quanta)
beats = audiofile.analysis.beats
# create a new empty list of Audio Quanta
collect = audio.AudioQuantumList()
# add the first segment in each beat in sequence
for beat in beats:
# beat.children are the segments in this beat
# beat.children()[0] is the first segment
collect.append(beat.children()[0])
# Get the raw audio data for the audio quanta and store them in 'out'
out = audio.getpieces(audiofile, collect)
# encode the raw audio as the appropriate file type (using en-ffmpeg)
out.encode(output_filename)
def main(units, timbre_bin, input_filename, output_filename):
audiofile = audio.LocalAudioFile(input_filename)
chunks = audiofile.analysis.__getattribute__(units)
timbre_bin = int(timbre_bin)
# For any chunk, return the timbre value of the given bin
def sorting_function(chunk):
timbre = chunk.mean_timbre()
return timbre[timbre_bin]
sorted_chunks = sorted(chunks, key=sorting_function, reverse=reverse)
import pdb
#pdb.set_trace()
out = audio.getpieces(audiofile, sorted_chunks)
out.encode(output_filename)
def generate_new_song2(chunks, segments, input_filename, output_filename, audiofile, length=300):
out_chunks = audio.AudioQuantumList(kind="beats")
#start at beginning of song
#play for a while
#leave first 20 segments alone?
for i in range(20):
out_chunks.append(segments[i])
last_segment_played = segments[i]
#how many times to do this?
# I randomly put 300 segments here
while len(out_chunks) < length:
next_segment_to_play = last_segment_played.get_next_segment_to_play()
last_segment_played = next_segment_to_play
out_chunks.append(next_segment_to_play)
out = audio.getpieces(audiofile, out_chunks)
out.encode(output_filename)
def main():
#### We can't do this for multiple songs.
songs = glob.glob("songs/*.mp3")
filename = generate(songs)
beats = []
audiofile = audio.LocalAudioFile(filename)
beats = audiofile.analysis.beats
print "Number of beats %s" % len(beats)
samples = beats[::SAMPLING_STEP]
print "Number of samples to build cluster model %s" % len(samples)
cl = cluster.KMeansClustering(samples, distance_beats)
clusters = cl.getclusters(K)
print "Clustering completed"
for c in clusters:
c.centroid = None
pickle.dump(clusters, open("clustering.c", "wb"))
print "Pickled Cluster Model"
for c in clusters:
c.centroid = cluster.centroid(c)
print "Reset the centroids"
training_input = []
for beat in beats:
training_input.append(get_cluster_index(beat, clusters))
print("Training markovModel")
markov_model = MarkovModel()
markov_model.learn_ngram_distribution(training_input, NGRAM)
#### We should have his function as iterator.
print "Generating bunch of music"
output_list = markov_model.generate_a_bunch_of_text(len(training_input))
generated_beats = audio.AudioQuantumList()
print "Coming back to beats"
for index in output_list:
generated_beats.append(get_beats_back(index, clusters))
#### We can't do this for multiple songs.
print "Saving an Amazing Song"
out = audio.getpieces(audiofile, generated_beats)
out.encode("bunch_of_music.wav")
def getClosestBar(filename):
song0 = audio.LocalAudioFile("dhorse1.wav")
song = audio.LocalAudioFile(filename)
sections = song.analysis.sections
bars = song.analysis.bars
sectionStart = [q.start for q in sections][1:]
barStart = [b.start for b in bars]
VIPBars = []
for start in sectionStart:
for i in xrange(len(barStart) - 1):
if barStart[i] < start and barStart[i + 1] >= start:
VIPBars += [i]
#need to split the audio file based on the bar partitiion now
for barVal in VIPBars:
if barVal == VIPBars[0]: continue
smallBar = audio.getpieces(song, bars[barVal - 3:barVal + 3])
smallBar.encode("smallBar.wav")
smallBar = audio.LocalAudioFile("smallBar.wav")
print smallBar.analysis.segments
return featureAnalysis.main(smallBar, song0)
def main(input_filename, output_filename):
audiofile = audio.LocalAudioFile(input_filename)
duration = audiofile.analysis.duration
segments = audiofile.analysis.segments
bars = audiofile.analysis.bars
beats = audiofile.analysis.beats
print duration, " ", len(segments)
beats_in = beats_out = 0
if beats:
in_flow = {"music": abridge(bars, segments, 4), "pre_bar_beats": pre_post(beats, bars)[0],
"post_bar_beats": pre_post(beats, bars)[1]}
else:
in_flow = {"music": segments, "pre_bar_beats": 0,
"post_bar_beats": 0}
print in_flow['pre_bar_beats'], "pre-bar beats", in_flow['post_bar_beats'], "post-bar beats"
out = audio.getpieces(audiofile, in_flow["music"])
out.encode(output_filename)
def SendMP3OfSong(nextSong, nextSongStartBeat):
collect = audio.AudioQuantumList()
audiofile = audio.LocalAudioFile(str(nextSong.filePath))
oldBeats = audiofile.analysis.beats
beats = []
i = 0
for beat in oldBeats:
if i >= nextSongStartBeat:
collect.append(beat.children()[0])
i += 1
for beat in beats:
collect.append(beat.children()[0])
out = audio.getpieces(audiofile, collect)
# TODO: actual path here
out.encode("/tmp/".join(nextSong.title))
def main(infile, outfile, choices=4):
audiofile = audio.LocalAudioFile(infile)
meter = audiofile.analysis.time_signature['value']
sections = audiofile.analysis.sections
output = audio.AudioQuantumList()
for section in sections:
beats = []
bars = section.children()
for bar in bars:
beats.extend(bar.children())
beat_array = []
for m in range(meter):
metered_beats = []
for b in beats:
if beats.index(b) % meter == m:
metered_beats.append(b)
beat_array.append(metered_beats)
# Always start with the first beat
output.append(beat_array[0][0])
for x in range(1, len(bars) * meter):
meter_index = x % meter
next_candidates = beat_array[meter_index]
def sorting_function(chunk, target_chunk=output[-1]):
timbre = chunk.mean_timbre()
target_timbre = target_chunk.mean_timbre()
timbre_distance = numpy.linalg.norm(
numpy.array(timbre) - numpy.array(target_timbre))
return timbre_distance
next_candidates = sorted(next_candidates, key=sorting_function)
next_index = random.randint(0,
min(choices,
len(next_candidates) - 1))
output.append(next_candidates[next_index])
out = audio.getpieces(audiofile, output)
out.encode(outfile)
def main(input_filename, output_filename):
audiofile = audio.LocalAudioFile(input_filename)
'''
This line got the bars of the song in the previous version:
bars = audiofile.analysis.bars
Now, this line gets the beats in the song:
'''
beats = audiofile.analysis.beats
collect = audio.AudioQuantumList()
'''
This loop got the first beat in each bar and appended them to a list:
for bar in bars:
collect.append(bar.children()[0])
Now, this loop gets the first segment in each beat and appends them to the list:
'''
for b in beats:
collect.append(b.children()[0])
out = audio.getpieces(audiofile, collect)
out.encode(output_filename)
def main(units, input_filename):
audiofile = audio.LocalAudioFile(input_filename)
chunks = audiofile.analysis.__getattribute__(units)
timbre_range = range(11)
tonic = audiofile.analysis.key['value']
# For any chunk, return the timbre value of the given bin
def sorting_function(chunk):
timbre = chunk.mean_timbre()
return timbre[timbre_bin]
#loop through all 11 bins of timbre and output them
for timbre_bin in timbre_range:
print(timbre_bin)
sorted_chunks = sorted(chunks, key=sorting_function, reverse=reverse)
#would be nice to output string keys rather than bins
# just zip range 0-11 to (c, c-sharp, d, e-flat, e, f, f-sharp, g, a-flat, a, b-flat, b)
out = audio.getpieces(audiofile, sorted_chunks)
out.encode('chopped_%s_%s_%s' % (units,timbre_bin,tonic))
def main(units, inputFile, outputFile):
audiofile = audio.LocalAudioFile(inputFile)
collect = audio.AudioQuantumList()
if not audiofile.analysis.bars:
print "No bars found in this analysis!"
print "No output."
sys.exit(-1)
for b in audiofile.analysis.bars[0:-1]:
# all but the last beat
collect.extend(b.children()[0:-1])
if units.startswith("tatum"):
# all but the last half (round down) of the last beat
half = - (len(b.children()[-1].children()) // 2)
collect.extend(b.children()[-1].children()[0:half])
# endings were rough, so leave everything after the start
# of the final bar intact:
last = audio.AudioQuantum(audiofile.analysis.bars[-1].start,
audiofile.analysis.duration -
audiofile.analysis.bars[-1].start)
collect.append(last)
out = audio.getpieces(audiofile, collect)
out.encode(outputFile)
def main(infile, outfile, choices=4, bars=40):
audiofile = audio.LocalAudioFile(infile)
meter = audiofile.analysis.time_signature['value']
fade_in = audiofile.analysis.end_of_fade_in
fade_out = audiofile.analysis.start_of_fade_out
beats = []
for b in audiofile.analysis.beats:
if b.start > fade_in or b.end < fade_out:
beats.append(b)
output = audio.AudioQuantumList()
beat_array = []
for m in range(meter):
metered_beats = []
for b in beats:
if beats.index(b) % meter == m:
metered_beats.append(b)
beat_array.append(metered_beats)
# Always start with the first beat
output.append(beat_array[0][0])
for x in range(1, bars * meter):
meter_index = x % meter
next_candidates = beat_array[meter_index]
def sorting_function(chunk, target_chunk=output[-1]):
timbre = chunk.mean_pitches()
target_timbre = target_chunk.mean_pitches()
timbre_distance = numpy.linalg.norm(
numpy.array(timbre) - numpy.array(target_timbre))
return timbre_distance
next_candidates = sorted(next_candidates, key=sorting_function)
next_index = random.randint(0, min(choices, len(next_candidates) - 1))
output.append(next_candidates[next_index])
out = audio.getpieces(audiofile, output)
out.encode(outfile)
def main(input_filename, output_filename):
# This takes your input track, sends it to the analyzer, and returns the results.
audiofile = audio.LocalAudioFile(input_filename)
# This gets a list of every bar in the track.
# You can manipulate this just like any other Python list!
bars = audiofile.analysis.bars
# This makes a new list of "AudioQuantums".
# Those are just any discrete chunk of audio: bars, beats, etc.
collect = audio.AudioQuantumList()
# This loop puts the first item in the children of each bar into the new list.
# A bar's children are beats! Simple as that.
for bar in bars:
collect.append(bar.children()[0])
# This assembles the pieces of audio defined in collect from the analyzed audio file.
out = audio.getpieces(audiofile, collect)
# This writes the newly created audio to the given file.
out.encode(output_filename)
def main(units, inputFile, outputFile):
audiofile = audio.LocalAudioFile(inputFile)
collect = audio.AudioQuantumList()
if not audiofile.analysis.bars:
print "No bars found in this analysis!"
print "No output."
sys.exit(-1)
for b in audiofile.analysis.bars[0:-1]:
# all but the last beat
collect.extend(b.children()[0:-1])
if units.startswith("tatum"):
# all but the last half (round down) of the last beat
half = -(len(b.children()[-1].children()) // 2)
collect.extend(b.children()[-1].children()[0:half])
# endings were rough, so leave everything after the start
# of the final bar intact:
last = audio.AudioQuantum(
audiofile.analysis.bars[-1].start,
audiofile.analysis.duration - audiofile.analysis.bars[-1].start)
collect.append(last)
out = audio.getpieces(audiofile, collect)
out.encode(outputFile)
def main(input_filename, output_filename):
# This takes your input track, sends it to the analyzer, and returns the results.
audiofile = audio.LocalAudioFile(input_filename)
# This gets a list of every bar in the track.
# You can manipulate this just like any other Python list!
bars = audiofile.analysis.bars
# This makes a new list of "AudioQuantums".
# Those are just any discrete chunk of audio: bars, beats, etc.
collect = audio.AudioQuantumList()
# This loop puts the first item in the children of each bar into the new list.
# A bar's children are beats! Simple as that.
for bar in bars:
collect.append(bar.children()[0])
# This assembles the pieces of audio defined in collect from the analyzed audio file.
out = audio.getpieces(audiofile, collect)
# This writes the newly created audio to the given file.
out.encode(output_filename)
def main(infile, outfile, choices=4, bars=40):
audiofile = audio.LocalAudioFile(infile)
meter = audiofile.analysis.time_signature['value']
fade_in = audiofile.analysis.end_of_fade_in
fade_out = audiofile.analysis.start_of_fade_out
beats = []
for b in audiofile.analysis.beats:
if b.start > fade_in or b.end < fade_out:
beats.append(b)
output = audio.AudioQuantumList()
beat_array = []
for m in range(meter):
metered_beats = []
for b in beats:
if beats.index(b) % meter == m:
metered_beats.append(b)
beat_array.append(metered_beats)
# Always start with the first beat
output.append(beat_array[0][0]);
for x in range(1, bars * meter):
meter_index = x % meter
next_candidates = beat_array[meter_index]
def sorting_function(chunk, target_chunk=output[-1]):
timbre = chunk.mean_pitches()
target_timbre = target_chunk.mean_pitches()
timbre_distance = numpy.linalg.norm(numpy.array(timbre) - numpy.array(target_timbre))
return timbre_distance
next_candidates = sorted(next_candidates, key=sorting_function)
next_index = random.randint(0, min(choices, len(next_candidates) -1 ))
output.append(next_candidates[next_index])
out = audio.getpieces(audiofile, output)
out.encode(outfile)
def do_something(sFileToConvert, nTempoToHit, nPitchOffset, nLoudness, sGenre):#dJoined):
#audiofile.save() #apparently can cache analysis.
fFile = open('music/' + sGenre, 'r')
aTimbres = cPickle.load(fFile)
fFile.close()
#print('using timbres:' + str(aTimbres))
mod = my_mod_class()
track = audio.LocalAudioFile(sFileToConvert, verbose='verbose')
#need to set the track's shape to match the two channel sound?
beats = track.analysis.beats
out_shape = (len(track.data),2)
anNewBeats = audio.AudioData(shape=out_shape, numChannels=2, sampleRate=44100)
#print(track.analysis.key)
for i, beat in enumerate(beats):
#data = track[beat].data
anNewBeats.append( mod.shiftPitchSemiTones( track[beat], int( nPitchOffset *1.5) ) )
#convert from key to pitch
track.data = anNewBeats
segments = track.analysis.segments
print(track.analysis.tempo['value'])
fScaleTime = nTempoToHit / track.analysis.tempo['value']
chunks = []
for segment in segments:
segment.duration = segment.duration /fScaleTime
anTimbreDistances = []
for anTimbre in aTimbres:
timbre_diff = numpy.subtract(segment.timbre,anTimbre)
anTimbreDistances.append(numpy.sum(numpy.square(timbre_diff)))
segment.timbre = aTimbres[anTimbreDistances.index(min(anTimbreDistances))]
chunks.append(segment)
print(track.analysis.tempo['value'])
modAudio = audio.getpieces(track.data, chunks)
audio.fadeEdges(modAudio.data)
#modAudio = audio.fadeEdges(modAudio.data)
modAudio.encode('niceout.wav')
def main(infile, outfile, choices=4):
audiofile = audio.LocalAudioFile(infile)
meter = audiofile.analysis.time_signature['value']
sections = audiofile.analysis.sections
output = audio.AudioQuantumList()
for section in sections:
beats = []
bars = section.children()
for bar in bars:
beats.extend(bar.children())
beat_array = []
for m in range(meter):
metered_beats = []
for b in beats:
if beats.index(b) % meter == m:
metered_beats.append(b)
beat_array.append(metered_beats)
# Always start with the first beat
output.append(beat_array[0][0]);
for x in range(1, len(bars) * meter):
meter_index = x % meter
next_candidates = beat_array[meter_index]
def sorting_function(chunk, target_chunk=output[-1]):
timbre = chunk.mean_timbre()
target_timbre = target_chunk.mean_timbre()
timbre_distance = numpy.linalg.norm(numpy.array(timbre) - numpy.array(target_timbre))
return timbre_distance
next_candidates = sorted(next_candidates, key=sorting_function)
next_index = random.randint(0, min(choices, len(next_candidates) - 1))
output.append(next_candidates[next_index])
out = audio.getpieces(audiofile, output)
out.encode(outfile)
def main(toReverse, inputFilename, outputFilename):
# This takes your input track, sends it to the analyzer, and returns the results.
audioFile = audio.LocalAudioFile(inputFilename)
# Checks what sort of reversing we're doing.
if toReverse == 'beats':
# This gets a list of every beat in the track.
chunks = audioFile.analysis.beats
elif toReverse == 'segments':
# This gets a list of every segment in the track.
# Segments are the smallest chunk of audio that Remix deals with
chunks = audioFile.analysis.segments
else:
print usage
return
# Reverse the list!
chunks.reverse()
# This assembles the pieces of audio defined in chunks from the analyzed audio file.
reversedAudio = audio.getpieces(audioFile, chunks)
# This writes the newly created audio to the given file.
reversedAudio.encode(outputFilename)
def main(units, inputFile, outputFile):
# This takes your input track, sends it to the analyzer, and returns the results.
audiofile = audio.LocalAudioFile(inputFile)
# This makes a new list of "AudioQuantums".
# Those are just any discrete chunk of audio: bars, beats, etc
collect = audio.AudioQuantumList()
# If the analysis can't find any bars, stop!
# (This might happen with really ambient music)
if not audiofile.analysis.bars:
print "No bars found in this analysis!"
print "No output."
sys.exit(-1)
# This loop puts all but the last of each bar into the new list!
for b in audiofile.analysis.bars[0:-1]:
collect.extend(b.children()[0:-1])
# If we're using tatums instead of beats, we want all but the last half (round down) of the last beat
# A tatum is the smallest rhythmic subdivision of a beat -- http://en.wikipedia.org/wiki/Tatum_grid
if units.startswith("tatum"):
half = -(len(b.children()[-1].children()) // 2)
collect.extend(b.children()[-1].children()[0:half])
# Endings were rough, so leave everything after the start of the final bar intact:
last = audio.AudioQuantum(
audiofile.analysis.bars[-1].start,
audiofile.analysis.duration - audiofile.analysis.bars[-1].start)
collect.append(last)
# This assembles the pieces of audio defined in collect from the analyzed audio file.
out = audio.getpieces(audiofile, collect)
# This writes the newly created audio to the given file.
out.encode(outputFile)
def renderSample(path_to_audio_file):
audio_file = audio.LocalAudioFile(path_to_audio_file)
beats = audio_file.analysis.beats
branches = similarSamples(audio_file, threshold = 250)
# get the beats of interest
branch, collect = [], []
for each in branches:
branch.append(each)
#branch.append(branches[each][0])
# beats re-ordered for rendering
for each in branch:
collect.append(beats[each])
out = audio.getpieces(audio_file, collect)
name = path_to_audio_file.split('/')
output_file = "./mixed/" + name[len(name)-1].split('.')[0] + "_out.mp3"
out.encode(output_file)
return
def main(input_filename, output_filename, break_filename, break_parts, measures, mix):
# This takes the input tracks, sends them to the analyzer, and returns the results.
audiofile = audio.LocalAudioFile(input_filename)
sample_rate = audiofile.sampleRate
breakfile = audio.LocalAudioFile(break_filename)
# This converts the break to stereo, if it is mono
if breakfile.numChannels == 1:
breakfile = mono_to_stereo(breakfile)
# This gets the number of channels in the main file
num_channels = audiofile.numChannels
# This splits the break into each beat
drum_data = split_break(breakfile, break_parts)
hits_per_beat = int(break_parts/(4 * measures))
# This gets the bars from the input track
bars = audiofile.analysis.bars
# This creates the 'shape' of new array.
# (Shape is a tuple (x, y) that indicates the length per channel of the audio file)
out_shape = (len(audiofile)+100000,num_channels)
# This creates a new AudioData array to write data to
out = audio.AudioData(shape=out_shape, sampleRate=sample_rate,
numChannels=num_channels)
if not bars:
# If the analysis can't find any bars, stop!
# (This might happen with really ambient music)
print "Didn't find any bars in this analysis!"
print "No output."
sys.exit(-1)
# This is where the magic happens:
# For every beat in every bar except the last bar,
# map the tatums of the break to the tatums of the beat
for bar in bars[:-1]:
# This gets the beats in the bar, and loops over them
beats = bar.children()
for i in range(len(beats)):
# This gets the index of matching beat in the break
try:
break_index = ((bar.local_context()[0] %\
measures) * 4) + (i % 4)
except ValueError:
break_index = i % 4
# This gets the tatums from the beat of the break
tats = range((break_index) * hits_per_beat,
(break_index + 1) * hits_per_beat)
# This gets the number of samples in each tatum
drum_samps = sum([len(drum_data[x]) for x in tats])
# This gets the number of sample and the shape of the beat from the original track
beat_samps = len(audiofile[beats[i]])
beat_shape = (beat_samps,num_channels)
# This get the shape of each tatum
tat_shape = (float(beat_samps/hits_per_beat),num_channels)
# This creates the new AudioData that will be filled with chunks of the drum break
beat_data= audio.AudioData(shape=beat_shape,
sampleRate=sample_rate,
numChannels=num_channels)
for j in tats:
# This creates an audioData for each tatum
tat_data= audio.AudioData(shape=tat_shape,
sampleRate=sample_rate,
numChannels=num_channels)
# This corrects for length / timing:
# If the original is shorter than the break, truncate drum hits to fit beat length
if drum_samps > beat_samps/hits_per_beat:
tat_data.data = drum_data[j].data[:len(tat_data)]
# If the original is longer, space out drum hits to fit beat length
elif drum_samps < beat_samps/hits_per_beat:
tat_data.append(drum_data[j])
# This adds each new tatum to the new beat.
tat_data.endindex = len(tat_data)
beat_data.append(tat_data)
del(tat_data)
# This corrects for rounding errors
beat_data.endindex = len(beat_data)
# This mixes the new beat data with the input data, and appends it to the final file
mixed_beat = audio.mix(beat_data, audiofile[beats[i]], mix=mix)
del(beat_data)
out.append(mixed_beat)
# This works out the last beat and appends it to the final file
finale = bars[-1].start + bars[-1].duration
last = audio.AudioQuantum(audiofile.analysis.bars[-1].start,
audiofile.analysis.duration -
audiofile.analysis.bars[-1].start)
last_data = audio.getpieces(audiofile,[last])
out.append(last_data)
# This writes the newly created audio to the given file.
out.encode(output_filename)
def main(input_filename, output_filename, break_filename, break_parts,
measures, mix):
audiofile = audio.LocalAudioFile(input_filename)
sample_rate = audiofile.sampleRate
breakfile = audio.LocalAudioFile(break_filename)
if breakfile.numChannels == 1:
breakfile = mono_to_stereo(breakfile)
num_channels = audiofile.numChannels
drum_data = split_break(breakfile, break_parts)
hits_per_beat = int(break_parts / (4 * measures))
bars = audiofile.analysis.bars
out_shape = (len(audiofile) + 100000, num_channels)
out = audio.AudioData(shape=out_shape,
sampleRate=sample_rate,
numChannels=num_channels)
if not bars:
print "Didn't find any bars in this analysis!"
print "No output."
sys.exit(-1)
for bar in bars[:-1]:
beats = bar.children()
for i in range(len(beats)):
try:
break_index = ((bar.local_context()[0] %\
measures) * 4) + (i % 4)
except ValueError:
break_index = i % 4
tats = range((break_index) * hits_per_beat,
(break_index + 1) * hits_per_beat)
drum_samps = sum([len(drum_data[x]) for x in tats])
beat_samps = len(audiofile[beats[i]])
beat_shape = (beat_samps, num_channels)
tat_shape = (float(beat_samps / hits_per_beat), num_channels)
beat_data = audio.AudioData(shape=beat_shape,
sampleRate=sample_rate,
numChannels=num_channels)
for j in tats:
tat_data = audio.AudioData(shape=tat_shape,
sampleRate=sample_rate,
numChannels=num_channels)
if drum_samps > beat_samps / hits_per_beat:
# truncate drum hits to fit beat length
tat_data.data = drum_data[j].data[:len(tat_data)]
elif drum_samps < beat_samps / hits_per_beat:
# space out drum hits to fit beat length
#temp_data = add_fade_out(drum_data[j])
tat_data.append(drum_data[j])
tat_data.endindex = len(tat_data)
beat_data.append(tat_data)
del (tat_data)
# account for rounding errors
beat_data.endindex = len(beat_data)
mixed_beat = audio.mix(beat_data, audiofile[beats[i]], mix=mix)
del (beat_data)
out.append(mixed_beat)
finale = bars[-1].start + bars[-1].duration
last = audio.AudioQuantum(
audiofile.analysis.bars[-1].start,
audiofile.analysis.duration - audiofile.analysis.bars[-1].start)
last_data = audio.getpieces(audiofile, [last])
out.append(last_data)
out.encode(output_filename)
"""Reverse a song by playing its beats forward starting from the end of the song"""
import echonest.remix.audio as audio
# Easy around wrapper mp3 decoding and Echo Nest analysis
audio_file = audio.LocalAudioFile("file_example_WAV_1MG.wav")
# You can manipulate the beats in a song as a native python list
beats = audio_file.analysis.beats
beats.reverse()
# And render the list as a new audio file!
audio.getpieces(audio_file,
beats).encode("file_example_WAV_1MGBackwardsByBeat.wav")
def main(input_filename, output_filename, break_filename, break_parts,
measures, mix, samples_dir):
print break_filename
audiofile = audio.LocalAudioFile(input_filename)
sample_rate = audiofile.sampleRate
breakfile = audio.LocalAudioFile(break_filename)
if breakfile.numChannels == 1:
breakfile = mono_to_stereo(breakfile)
num_channels = audiofile.numChannels
drum_data = split_break(breakfile, break_parts)
hits_per_beat = int(break_parts / (4 * measures))
bars = audiofile.analysis.bars
out_shape = (len(audiofile) + 100000, num_channels)
out = audio.AudioData(shape=out_shape,
sampleRate=sample_rate,
numChannels=num_channels)
if not bars:
print "Didn't find any bars in this analysis!"
print "No output."
sys.exit(-1)
for bar in bars[:-1]:
beats = bar.children()
for i in range(len(beats)):
try:
break_index = ((bar.local_context()[0] %\
measures) * 4) + (i % 4)
except ValueError:
break_index = i % 4
tats = range((break_index) * hits_per_beat,
(break_index + 1) * hits_per_beat)
drum_samps = sum([len(drum_data[x]) for x in tats])
beat_samps = len(audiofile[beats[i]])
beat_shape = (beat_samps, num_channels)
tat_shape = (float(beat_samps / hits_per_beat), num_channels)
beat_data = audio.AudioData(shape=beat_shape,
sampleRate=sample_rate,
numChannels=num_channels)
for j in tats:
tat_data = audio.AudioData(shape=tat_shape,
sampleRate=sample_rate,
numChannels=num_channels)
if drum_samps > beat_samps / hits_per_beat:
# truncate drum hits to fit beat length
tat_data.data = drum_data[j].data[:len(tat_data)]
elif drum_samps < beat_samps / hits_per_beat:
# space out drum hits to fit beat length
#temp_data = add_fade_out(drum_data[j])
tat_data.append(drum_data[j])
tat_data.endindex = len(tat_data)
beat_data.append(tat_data)
del (tat_data)
# account for rounding errors
beat_data.endindex = len(beat_data)
mixed_beat = audio.mix(beat_data, audiofile[beats[i]], mix=mix)
del (beat_data)
out.append(mixed_beat)
finale = bars[-1].start + bars[-1].duration
last = audio.AudioQuantum(
audiofile.analysis.bars[-1].start,
audiofile.analysis.duration - audiofile.analysis.bars[-1].start)
last_data = audio.getpieces(audiofile, [last])
out.append(last_data)
samples_avail = os.listdir(samples_dir)
#throw down some classic trap samples
#the outfile should be the same length as the output file, so just go through that file instead
for section in audiofile.analysis.sections[1:]:
overlay_sound_file = pickSample(samples_avail)
soundpath = os.path.join(str(samples_dir), overlay_sound_file)
print soundpath
sample = audio.LocalAudioFile(soundpath)
# Mix the audio
volume = 0.9
pan = 0
startsample = int(section.start * out.sampleRate)
seg = sample[0:]
seg.data *= (volume - (pan * volume), volume + (pan * volume)
) # pan + volume
if out.data.shape[0] - startsample > seg.data.shape[0]:
out.data[startsample:startsample + len(seg.data)] += seg.data[0:]
out.encode(output_filename)
def render_clusters(afile, clusters, filename):
for i, clust in enumerate(clusters):
out = audio.getpieces(afile, clust)
filename = '%s-cluster-%i.wav' % (filename.split('.'), i)
out.encode(filename)
