def computeBpmHistogram(self,
noveltyCurve,
frameSize=4,
overlap=2,
frameRate=44100. / 128.,
window='hann',
zeroPadding=0,
constantTempo=False,
minBpm=30):
pool = Pool()
bpmHist = ess.BpmHistogram(frameRate=frameRate,
frameSize=frameSize,
overlap=overlap,
zeroPadding=zeroPadding,
constantTempo=constantTempo,
windowType='hann',
minBpm=minBpm)
gen = ess.VectorInput(noveltyCurve)
gen.data >> bpmHist.novelty
bpmHist.bpm >> (pool, 'bpm')
bpmHist.bpmCandidates >> (pool, 'bpmCandidates')
bpmHist.bpmMagnitudes >> (pool, 'bpmMagnitudes')
bpmHist.frameBpms >> None #(pool, 'frameBpms')
bpmHist.tempogram >> (pool, 'tempogram')
bpmHist.ticks >> (pool, 'ticks')
bpmHist.ticksMagnitude >> (pool, 'ticksMagnitude')
bpmHist.sinusoid >> (pool, 'sinusoid')
essentia.run(gen)
return pool
def testRegressionStreaming(self):
"""Tests streaming ChromaCrossSimilarity algo with 'otiBinary=True' against the standard mode algorithm with 'otiBinary=True' """
# compute chromacrosssimilarity matrix using streaming mode
queryVec = ess.VectorInput(self.query_hpcp)
csm_streaming = ess.ChromaCrossSimilarity(referenceFeature=self.reference_hpcp, oti=0, frameStackSize=1)
pool = Pool()
queryVec.data >> csm_streaming.queryFeature
csm_streaming.csm >> (pool, 'csm')
ess_run(queryVec)
self.assertAlmostEqualMatrix(self.expected_oti_simmatrix, np.array(pool['csm']))
def chromaprint(self, analysisTime=30):
"""
This algorithm computes the fingerprint of the input signal using Chromaprint algorithm.
It is a wrapper of the Chromaprint library
Returns: The chromaprints are returned as base64-encoded strings.
"""
vec_input = ess.VectorInput(self.audio_vector)
chromaprinter = ess.Chromaprinter(analysisTime=analysisTime, sampleRate=self.fs)
pool = Pool()
vec_input.data >> chromaprinter.signal
chromaprinter.fingerprint >> (pool, 'chromaprint')
run(vec_input)
return pool['chromaprint']
def testStreaming(self):
signal = [0] * 44100
onsets = [0, 0.05, 0.07, 0.08, 0.085, 0.1, 0.5, 0.8, 0.9]
# standard version works correctly, and will be used as a reference:
expected = AudioOnsetsMarker(sampleRate=44100, onsets=onsets)(signal)
# streaming version is the one that fails:
pool = Pool()
gen = es.VectorInput(signal)
onsetMarker = es.AudioOnsetsMarker(sampleRate=44100, onsets=onsets)
gen.data >> onsetMarker.signal
onsetMarker.signal >> (pool, "markedOnsets")
run(gen)
self.assertEqualVector(pool['markedOnsets'], expected)
def tonalAnalysis(self, signal):
vectorinput = ess.VectorInput(np.single(signal))
framecutter = ess.FrameCutter(frameSize=4096,
hopSize=2048,
silentFrames='noise')
windowing = ess.Windowing(type='blackmanharris62')
spectrum = ess.Spectrum()
spectralpeaks = ess.SpectralPeaks(orderBy='frequency',
magnitudeThreshold=1e-5,
minFrequency=20,
maxFrequency=3500,
maxPeaks=60)
dissonance = ess.Dissonance()
tuning_frequency = ess.TuningFrequency()
inharmonicity = ess.Inharmonicity()
# Use pool to store data
pool = essentia.Pool()
# Connect streaming algorithms
vectorinput.data >> framecutter.signal
framecutter.frame >> windowing.frame >> spectrum.frame
spectrum.spectrum >> spectralpeaks.spectrum
spectralpeaks.magnitudes >> dissonance.magnitudes
spectralpeaks.frequencies >> dissonance.frequencies
spectralpeaks.magnitudes >> tuning_frequency.magnitudes
spectralpeaks.frequencies >> tuning_frequency.frequencies
spectralpeaks.magnitudes >> inharmonicity.magnitudes
spectralpeaks.frequencies >> inharmonicity.frequencies
dissonance.dissonance >> (pool, 'tonal.dissonance')
inharmonicity.inharmonicity >> (pool, 'tonal.inharmonicity')
tuning_frequency.tuningFrequency >> (pool, 'tonal.tuningFrequency')
tuning_frequency.tuningCents >> (pool, 'tonal.tuningCents')
# Run streaming network
essentia.run(vectorinput)
return pool['tonal.dissonance'], pool['tonal.inharmonicity'], pool[
'tonal.tuningFrequency']
def sfxPitch(pool, namespace=''):
sfxspace = 'sfx.'
llspace = 'lowlevel.'
if namespace:
sfxspace = namespace + '.sfx.'
llspace = namespace + '.lowlevel.'
pitch = pool[llspace+'pitch']
gen = streaming.VectorInput(pitch)
maxtt = streaming.MaxToTotal()
mintt = streaming.MinToTotal()
amt = streaming.AfterMaxToBeforeMaxEnergyRatio()
gen.data >> maxtt.envelope
gen.data >> mintt.envelope
gen.data >> amt.pitch
maxtt.maxToTotal >> (pool, sfxspace+'pitch_max_to_total')
mintt.minToTotal >> (pool, sfxspace+'pitch_min_to_total')
amt.afterMaxToBeforeMaxEnergyRatio >> (pool, sfxspace+'pitch_after_max_to_before_max_energy_ratio')
essentia.run(gen)
pc = standard.Centroid(range=len(pitch)-1)(pitch)
pool.set(sfxspace+'pitch_centroid', pc)
# analysis loader.audio >> fcut.signal fcut.frame >> w.frame w.frame >> fft.frame fft.fft >> smanal.fft smanal.magnitudes >> (pool, 'magnitudes') smanal.frequencies >> (pool, 'frequencies') smanal.phases >> (pool, 'phases') # subtraction fcut.frame >> smsub.frame smanal.magnitudes >> smsub.magnitudes smanal.frequencies >> smsub.frequencies smanal.phases >> smsub.phases smsub.frame >> (pool, 'frames') essentia.run(loader) #store to file outaudio = pool['frames'].flatten() awrite = es.MonoWriter (filename = outputFilename, sampleRate = params['sampleRate']); outvector = es.VectorInput(outaudio) outvector.data >> awrite.audio essentia.run(outvector)
