def hfc(filename):
audio = MonoLoader(filename=filename, sampleRate=44100)()
features = []
for frame in FrameGenerator(audio, frameSize = 1024, hopSize = 512):
mag, phase =CartesianToPolar()(FFT()(Windowing(type='hann')(frame)))
features.append(OnsetDetection(method='hfc')(mag, phase))
return Onsets()(array([features]),[1])
def calculateDownbeats(self, audio, bpm, phase):
# Step 0: calculate the CSD (Complex Spectral Difference) features
# and the associated onset detection function ON LOWPASSED SIGNAL
spec = Spectrum(size=self.FRAME_SIZE)
w = Windowing(type='hann')
fft = FFT()
c2p = CartesianToPolar()
od_csd = OnsetDetection(method='complex')
lowpass = LowPass(cutoffFrequency=1500)
pool = Pool()
# TODO test faster (numpy) way
#audio = lowpass(audio)
for frame in FrameGenerator(audio,
frameSize=self.FRAME_SIZE,
hopSize=self.HOP_SIZE):
mag, ph = c2p(fft(w(frame)))
pool.add('onsets.complex', od_csd(mag, ph))
# Step 1: normalise the data using an adaptive mean threshold
novelty_mean = self.adaptive_mean(pool['onsets.complex'], 16.0)
# Step 2: half-wave rectify the result
novelty_hwr = (pool['onsets.complex'] - novelty_mean).clip(min=0)
# Step 7 (experimental): Determine downbeat locations as subsequence with highest complex spectral difference
for i in range(4):
phase_frames = (phase * 44100.0) / (512.0)
frames = (
np.round(
np.arange(phase_frames + i * self.numFramesPerBeat(bpm),
np.size(novelty_hwr),
4 * self.numFramesPerBeat(bpm))).astype('int')
)[:
-1] # Discard last value to prevent reading beyond array (last value rounded up for example)
pool.add('output.downbeat',
np.sum(novelty_hwr[frames]) / np.size(frames))
plt.subplot(4, 1, i + 1)
plt.plot(novelty_hwr)
for f in frames:
plt.axvline(x=f)
print pool['output.downbeat']
downbeatIndex = np.argmax(pool['output.downbeat'])
plt.show()
# experimental
return 1.0 * self.beats[downbeatIndex::4]
def run(self, audio):
# Calculate the melflux onset detection function
pool = Pool()
w = Windowing(type='hann')
fft = np.fft.fft
od_flux = OnsetDetection(method='melflux')
for frame in FrameGenerator(audio,
frameSize=self.FRAME_SIZE,
hopSize=self.HOP_SIZE):
pool.add('audio.windowed_frames', w(frame))
fft_result = fft(pool['audio.windowed_frames']).astype('complex64')
fft_result_mag = np.absolute(fft_result)
fft_result_ang = np.angle(fft_result)
self.fft_mag_1024_512 = fft_result_mag
self.fft_phase_1024_512 = fft_result_ang
for mag, phase in zip(fft_result_mag, fft_result_ang):
pool.add('onsets.complex', od_flux(mag, phase))
odf = pool['onsets.complex']
# Given the ODF, calculate the tempo and the phase
tempo, tempo_curve, phase, phase_curve = BeatTracker.get_tempo_and_phase_from_odf(
odf, self.HOP_SIZE)
# Calculate the beat annotations
spb = 60. / tempo #seconds per beat
beats = (np.arange(phase,
(np.size(audio) / self.SAMPLE_RATE) - spb + phase,
spb).astype('single'))
# Store all the results
self.bpm = tempo
self.phase = phase
self.beats = beats
self.onset_curve = BeatTracker.hwr(pool['onsets.complex'])
def f_essentia_extract(Audio):
## METODOS DE LIBRERIA QUE DETECTAN DONDE OCURRE CADA NOTA RESPECTO AL TIEMPO
od2 = OnsetDetection(method='complex')
# Let's also get the other algorithms we will need, and a pool to store the results
w = Windowing(type='hann')
fft = FFT() # this gives us a complex FFT
c2p = CartesianToPolar(
) # and this turns it into a pair (magnitude, phase)
pool = essentia.Pool()
# Computing onset detection functions.
for frame in FrameGenerator(Audio, frameSize=1024, hopSize=512):
mag, phase, = c2p(fft(w(frame)))
pool.add('features.complex', od2(mag, phase))
## inicio de cada "nota"
onsets = Onsets()
tiempos_detectados_essentia = onsets(
essentia.array([pool['features.complex']]), [1])
#print(tiempos_detectados_essentia)
return tiempos_detectados_essentia
def run(self, audio):
def numFramesPerBeat(bpm):
return (60.0 * self.SAMPLE_RATE) / (self.HOP_SIZE * bpm)
def autocorr(x):
result = np.correlate(x, x, mode='full')
return result[result.size / 2:]
def adaptive_mean(x, N):
return np.convolve(x, [1.0] * int(N), mode='same') / N
# Step 0: calculate the CSD (Complex Spectral Difference) features
# and the associated onset detection function
spec = Spectrum(size=self.FRAME_SIZE)
w = Windowing(type='hann')
fft = np.fft.fft
c2p = CartesianToPolar()
od_csd = OnsetDetection(method='melflux')
pool = Pool()
for frame in FrameGenerator(audio,
frameSize=self.FRAME_SIZE,
hopSize=self.HOP_SIZE):
pool.add('audio.windowed_frames', w(frame))
fft_result = fft(pool['audio.windowed_frames']).astype('complex64')
fft_result_mag = np.absolute(fft_result)
fft_result_ang = np.angle(fft_result)
for mag, phase in zip(fft_result_mag, fft_result_ang):
pool.add('onsets.complex', od_csd(mag, phase))
# Step 1: normalise the data using an adaptive mean threshold
novelty_mean = adaptive_mean(pool['onsets.complex'], 16.0)
# Step 2: half-wave rectify the result
novelty_hwr = (pool['onsets.complex'] - novelty_mean).clip(min=0)
# Step 3: then calculate the autocorrelation of this signal
novelty_autocorr = autocorr(novelty_hwr)
# Step 4: Sum over constant intervals to detect most likely BPM
valid_bpms = np.arange(self.minBpm, self.maxBpm, self.stepBpm)
for bpm in valid_bpms:
frames = (
np.round(
np.arange(0, np.size(novelty_autocorr),
numFramesPerBeat(bpm))).astype('int')
)[:
-1] # Discard last value to prevent reading beyond array (last value rounded up for example)
pool.add('output.bpm',
np.sum(novelty_autocorr[frames]) / np.size(frames))
bpm = valid_bpms[np.argmax(pool['output.bpm'])]
# Step 5: Calculate phase information
valid_phases = np.arange(0.0, 60.0 / bpm,
0.001) # Valid phases in SECONDS
for phase in valid_phases:
# Convert phase from seconds to frames
phase_frames = (phase * 44100.0) / (512.0)
frames = (
np.round(
np.arange(phase_frames, np.size(novelty_hwr),
numFramesPerBeat(bpm))).astype('int')
)[:
-1] # Discard last value to prevent reading beyond array (last value rounded up for example)
pool.add('output.phase',
np.sum(novelty_hwr[frames]) / np.size(frames))
phase = valid_phases[np.argmax(pool['output.phase'])]
# Step 6: Determine the beat locations
spb = 60. / bpm #seconds per beat
beats = (np.arange(phase, (np.size(audio) / 44100) - spb + phase,
spb).astype('single'))
# Store all the results
self.bpm = bpm
self.phase = phase
self.beats = beats
def feature_allframes(song, frame_indexer=None):
audio = song.audio
beats = song.beats
fft_result_mag = song.fft_mag_1024_512
fft_result_ang = song.fft_phase_1024_512
od_hfc = OnsetDetection(method='flux')
pool = Pool()
HOP_SIZE = 512
for mag, phase in zip(fft_result_mag, fft_result_ang):
pool.add('onsets.flux', od_hfc(mag, phase))
# Normalize and half-rectify onset detection curve
def adaptive_mean(x, N):
return np.convolve(x, [1.0] * int(N), mode='same') / N
novelty_mean = adaptive_mean(pool['onsets.flux'], 16.0)
novelty_hwr = (pool['onsets.flux'] - novelty_mean).clip(min=0)
novelty_hwr = novelty_hwr / np.average(novelty_hwr)
# For every frame in frame_indexer,
if frame_indexer is None:
frame_indexer = range(
4,
len(beats) - 1
) # Exclude first frame, because it has no predecessor to calculate difference with
# Feature: correlation between current frame onset detection f and of previous frame
# Feature: correlation between current frame onset detection f and of next frame
# Feature: diff between correlation between current frame onset detection f and corr cur and next
onset_integrals = np.zeros((2 * len(beats), 1))
frame_i = (np.array(beats) * 44100.0 / HOP_SIZE).astype('int')
onset_correlations = np.zeros((len(beats), 21))
for i in [
i for i in range(len(beats))
if (i in frame_indexer) or (i + 1 in frame_indexer) or (
i - 1 in frame_indexer) or (i - 2 in frame_indexer) or (
i - 3 in frame_indexer) or (i - 4 in frame_indexer) or (
i - 5 in frame_indexer) or (
i - 6 in frame_indexer) or (i - 7 in frame_indexer)
]:
half_i = int((frame_i[i] + frame_i[i + 1]) / 2)
cur_frame_1st_half = novelty_hwr[frame_i[i]:half_i]
cur_frame_2nd_half = novelty_hwr[half_i:frame_i[i + 1]]
onset_integrals[2 * i] = np.sum(cur_frame_1st_half)
onset_integrals[2 * i + 1] = np.sum(cur_frame_2nd_half)
# Step 2: Calculate the cosine distance between the MFCC values
for i in frame_indexer:
# Correlation gives symmetrical results, which is not necessarily what we want.
# Better: integral of sum, multiplied by sign of difference
# If integral large a, b large but difference positive (a-b): a contains more onsets than
onset_correlations[i][0] = max(
np.correlate(novelty_hwr[frame_i[i - 1]:frame_i[i]],
novelty_hwr[frame_i[i]:frame_i[i + 1]],
mode='valid')) # Only 1 value
onset_correlations[i][1] = max(
np.correlate(novelty_hwr[frame_i[i]:frame_i[i + 1]],
novelty_hwr[frame_i[i + 1]:frame_i[i + 2]],
mode='valid')) # Only 1 value
onset_correlations[i][2] = max(
np.correlate(novelty_hwr[frame_i[i]:frame_i[i + 1]],
novelty_hwr[frame_i[i + 2]:frame_i[i + 3]],
mode='valid')) # Only 1 value
onset_correlations[i][3] = max(
np.correlate(novelty_hwr[frame_i[i]:frame_i[i + 1]],
novelty_hwr[frame_i[i + 3]:frame_i[i + 4]],
mode='valid')) # Only 1 value
# Difference in integrals of novelty curve between frames
# Quantifies the difference in number and prominence of onsets in this frame
onset_correlations[i][4] = onset_integrals[2 *
i] - onset_integrals[2 * i -
1]
onset_correlations[i][5] = onset_integrals[
2 * i + 2] + onset_integrals[2 * i + 3] - onset_integrals[
2 * i - 1] - onset_integrals[2 * i - 2]
for j in range(1, 16):
onset_correlations[i][
5 + j] = onset_integrals[2 * i + j] - onset_integrals[2 * i]
# Include the MFCC coefficients as features
result = onset_correlations[frame_indexer]
return preprocessing.scale(result)
def feature_allframes(audio, beats, frame_indexer = None):
# Initialise the algorithms
FRAME_SIZE = 1024
HOP_SIZE = 512
spec = Spectrum(size = FRAME_SIZE)
w = Windowing(type = 'hann')
fft = np.fft.fft
od_csd = OnsetDetection(method = 'complex')
od_hfc = OnsetDetection(method = 'flux')
pool = Pool()
# Calculate onset detection curve on audio
for frame in FrameGenerator(audio, frameSize = FRAME_SIZE, hopSize = HOP_SIZE):
pool.add('windowed_frames', w(frame))
fft_result = fft(pool['windowed_frames']).astype('complex64')
fft_result_mag = np.absolute(fft_result)
fft_result_ang = np.angle(fft_result)
for mag,phase in zip(fft_result_mag, fft_result_ang):
pool.add('onsets.flux', od_hfc(mag, phase))
# Normalize and half-rectify onset detection curve
def adaptive_mean(x, N):
return np.convolve(x, [1.0]*int(N), mode='same')/N
novelty_mean = adaptive_mean(pool['onsets.flux'], 16.0)
novelty_hwr = (pool['onsets.flux'] - novelty_mean).clip(min=0)
novelty_hwr = novelty_hwr / np.average(novelty_hwr)
# For every frame in frame_indexer,
if frame_indexer is None:
frame_indexer = list(range(4,len(beats) - 1)) # Exclude first frame, because it has no predecessor to calculate difference with
# Feature: correlation between current frame onset detection f and of previous frame
# Feature: correlation between current frame onset detection f and of next frame
# Feature: diff between correlation between current frame onset detection f and corr cur and next
onset_integrals = np.zeros((2 * len(beats), 1))
frame_i = (np.array(beats) * 44100.0/ HOP_SIZE).astype('int')
onset_correlations = np.zeros((len(beats), 21))
for i in [i for i in range(len(beats)) if (i in frame_indexer) or (i+1 in frame_indexer)
or (i-1 in frame_indexer) or (i-2 in frame_indexer) or (i-3 in frame_indexer)
or (i-4 in frame_indexer) or (i-5 in frame_indexer) or (i-6 in frame_indexer) or (i-7 in frame_indexer)]:
half_i = int((frame_i[i] + frame_i[i+1]) / 2)
cur_frame_1st_half = novelty_hwr[frame_i[i] : half_i]
cur_frame_2nd_half = novelty_hwr[half_i : frame_i[i+1]]
onset_integrals[2*i] = np.sum(cur_frame_1st_half)
onset_integrals[2*i + 1] = np.sum(cur_frame_2nd_half)
# Step 2: Calculate the cosine distance between the MFCC values
for i in frame_indexer:
onset_correlations[i][0] = max(np.correlate(novelty_hwr[frame_i[i-1] : frame_i[i]], novelty_hwr[frame_i[i] : frame_i[i+1]], mode='valid')) # Only 1 value
onset_correlations[i][1] = max(np.correlate(novelty_hwr[frame_i[i] : frame_i[i+1]], novelty_hwr[frame_i[i+1] : frame_i[i+2]], mode='valid')) # Only 1 value
onset_correlations[i][2] = max(np.correlate(novelty_hwr[frame_i[i] : frame_i[i+1]], novelty_hwr[frame_i[i+2] : frame_i[i+3]], mode='valid')) # Only 1 value
onset_correlations[i][3] = max(np.correlate(novelty_hwr[frame_i[i] : frame_i[i+1]], novelty_hwr[frame_i[i+3] : frame_i[i+4]], mode='valid')) # Only 1 value
# Difference in integrals of novelty curve between frames
# Quantifies the difference in number and prominence of onsets in this frame
onset_correlations[i][4] = onset_integrals[2*i] - onset_integrals[2*i-1]
onset_correlations[i][5] = onset_integrals[2*i+2] + onset_integrals[2*i+3] - onset_integrals[2*i-1] - onset_integrals[2*i-2]
for j in range(1,16):
onset_correlations[i][5 + j] = onset_integrals[2*i + j] - onset_integrals[2*i]
# Include the MFCC coefficients as features
result = onset_correlations[frame_indexer]
return preprocessing.scale(result)
ZeroCrossingRate, OddToEvenHarmonicEnergyRatio, EnergyBand, MetadataReader, OnsetDetection, Onsets, CartesianToPolar, FFT, MFCC, SingleGaussian from build_map import build_map sampleRate = 44100 frameSize = 2048 hopSize = 1024 windowType = "hann" mean = Mean() keyDetector = essentia.standard.Key(pcpSize=12) spectrum = Spectrum() window = Windowing(size=frameSize, zeroPadding=0, type=windowType) mfcc = MFCC() gaussian = SingleGaussian() od = OnsetDetection(method='hfc') fft = FFT() # this gives us a complex FFT c2p = CartesianToPolar() # and this turns it into a pair (magnitude, phase) onsets = Onsets(alpha=1) # dissonance spectralPeaks = SpectralPeaks(sampleRate=sampleRate, orderBy='frequency') dissonance = Dissonance() # barkbands barkbands = BarkBands(sampleRate=sampleRate) # zero crossing rate # zerocrossingrate = ZeroCrossingRate() # odd-to-even harmonic energy ratio
def run(self, audio):
# TODO put this in some util class
# Step 0: calculate the CSD (Complex Spectral Difference) features
# and the associated onset detection function
spec = Spectrum(size=self.FRAME_SIZE)
w = Windowing(type='hann')
fft = FFT()
c2p = CartesianToPolar()
od_csd = OnsetDetection(method='complex')
pool = Pool()
# TODO test faster (numpy) way
for frame in FrameGenerator(audio,
frameSize=self.FRAME_SIZE,
hopSize=self.HOP_SIZE):
mag, phase = c2p(fft(w(frame)))
pool.add('onsets.complex', od_csd(mag, phase))
# Step 1: normalise the data using an adaptive mean threshold
novelty_mean = self.adaptive_mean(pool['onsets.complex'], 16.0)
# Step 2: half-wave rectify the result
novelty_hwr = (pool['onsets.complex'] - novelty_mean).clip(min=0)
# Step 3: then calculate the autocorrelation of this signal
novelty_autocorr = self.autocorr(novelty_hwr)
# Step 4: Sum over constant intervals to detect most likely BPM
valid_bpms = np.arange(self.minBpm, self.maxBpm, self.stepBpm)
for bpm in valid_bpms:
frames = (
np.round(
np.arange(0, np.size(novelty_autocorr),
self.numFramesPerBeat(bpm))).astype('int')
)[:
-1] # Discard last value to prevent reading beyond array (last value rounded up for example)
pool.add('output.bpm',
np.sum(novelty_autocorr[frames]) / np.size(frames))
bpm = valid_bpms[np.argmax(pool['output.bpm'])]
# Step 5: Calculate phase information
valid_phases = np.arange(0.0, 60.0 / bpm,
0.001) # Valid phases in SECONDS
for phase in valid_phases:
# Convert phase from seconds to frames
phase_frames = (phase * 44100.0) / (512.0)
frames = (
np.round(
np.arange(phase_frames, np.size(novelty_hwr),
self.numFramesPerBeat(bpm))).astype('int')
)[:
-1] # Discard last value to prevent reading beyond array (last value rounded up for example)
pool.add('output.phase',
np.sum(novelty_hwr[frames]) / np.size(frames))
phase = valid_phases[np.argmax(pool['output.phase'])]
print 'PHASE', phase
# Step 6: Determine the beat locations
spb = 60. / bpm #seconds per beat
beats = (np.arange(phase, (np.size(audio) / 44100) - spb + phase,
spb).astype('single'))
# Store all the results
self.bpm = bpm
self.phase = phase
self.beats = beats
self.downbeats = self.calculateDownbeats(audio, bpm, phase)