From 25489e3b2b3e3cbd6a9a1701f48b5f5e9f7265aa Mon Sep 17 00:00:00 2001 From: Jorge Marcos Date: Mon, 12 Feb 2024 12:38:08 +0100 Subject: [PATCH 01/18] add class-based essentia algo header template --- src/cpp/includes/essentiajs.h | 2451 +++++++++++++++++++++++++++--- src/python/code_generator.py | 52 +- src/python/configure_bindings.py | 3 +- src/python/header.cog | 59 +- src/python/included_algos.md | 1 + 5 files changed, 2293 insertions(+), 273 deletions(-) diff --git a/src/cpp/includes/essentiajs.h b/src/cpp/includes/essentiajs.h index 8e0fb68..9069135 100644 --- a/src/cpp/includes/essentiajs.h +++ b/src/cpp/includes/essentiajs.h @@ -23,226 +23,2245 @@ #define ESSENTIAJS_H #include +#include +#include +#include +using namespace essentia; +using namespace essentia::standard; using namespace emscripten; -class EssentiaJS { +void init(); + +// method for generating frames from a given audio signal +class FrameGenerator { public: - // property to store the current essentia library version - std::string essentiaVersion; - // constructor for instantiating the essentia algo registry with an optional argument to enable debug mode - EssentiaJS(bool debugger=false); - ~EssentiaJS(){}; - // method for shutdown essentia instance - void shutdown(); - // method for generating frames from a given audio signal - std::vector > FrameGenerator(const val& signalArray, int frameSize, int hopSize); - val MonoMixer(std::vector& left_channel, std::vector& right_channel); - val LoudnessEBUR128(std::vector& left_channel, std::vector& right_channel, const float hopSize=0.1, const float sampleRate=44100, const bool startAtZero=false); - // NOTE: The following code snippets are machine generated. Do not edit. - - // class property which stores all the list of essentia algorithm names available in essentia.js - std::string algorithmNames = "['AfterMaxToBeforeMaxEnergyRatio', 'AllPass', 'AudioOnsetsMarker', 'AutoCorrelation', 'BFCC', 'BPF', 'BandPass', 'BandReject', 'BarkBands', 'BeatTrackerDegara', 'BeatTrackerMultiFeature', 'Beatogram', 'BeatsLoudness', 'BinaryOperator', 'BinaryOperatorStream', 'BpmHistogramDescriptors', 'BpmRubato', 'CentralMoments', 'Centroid', 'ChordsDescriptors', 'ChordsDetection', 'ChordsDetectionBeats', 'ChromaCrossSimilarity', 'Chromagram', 'ClickDetector', 'Clipper', 'CoverSongSimilarity', 'Crest', 'CrossCorrelation', 'CrossSimilarityMatrix', 'CubicSpline', 'DCRemoval', 'DCT', 'Danceability', 'Decrease', 'Derivative', 'DerivativeSFX', 'DiscontinuityDetector', 'Dissonance', 'DistributionShape', 'Duration', 'DynamicComplexity', 'ERBBands', 'EffectiveDuration', 'Energy', 'EnergyBand', 'EnergyBandRatio', 'Entropy', 'Envelope', 'EqualLoudness', 'Flatness', 'FlatnessDB', 'FlatnessSFX', 'Flux', 'FrameCutter', 'FrameToReal', 'FrequencyBands', 'GFCC', 'GapsDetector', 'GeometricMean', 'HFC', 'HPCP', 'HarmonicBpm', 'HarmonicPeaks', 'HighPass', 'HighResolutionFeatures', 'Histogram', 'HprModelAnal', 'HpsModelAnal', 'IDCT', 'IIR', 'Inharmonicity', 'InstantPower', 'Intensity', 'Key', 'KeyExtractor', 'LPC', 'Larm', 'Leq', 'LevelExtractor', 'LogAttackTime', 'LogSpectrum', 'LoopBpmConfidence', 'LoopBpmEstimator', 'Loudness', 'LoudnessVickers', 'LowLevelSpectralEqloudExtractor', 'LowLevelSpectralExtractor', 'LowPass', 'MFCC', 'MaxFilter', 'MaxMagFreq', 'MaxToTotal', 'Mean', 'Median', 'MedianFilter', 'MelBands', 'Meter', 'MinMax', 'MinToTotal', 'MovingAverage', 'MultiPitchKlapuri', 'MultiPitchMelodia', 'Multiplexer', 'NNLSChroma', 'NoiseAdder', 'NoiseBurstDetector', 'NoveltyCurve', 'NoveltyCurveFixedBpmEstimator', 'OddToEvenHarmonicEnergyRatio', 'OnsetDetection', 'OnsetDetectionGlobal', 'OnsetRate', 'OverlapAdd', 'PeakDetection', 'PercivalBpmEstimator', 'PercivalEnhanceHarmonics', 'PercivalEvaluatePulseTrains', 'PitchContourSegmentation', 'PitchContours', 'PitchContoursMelody', 'PitchContoursMonoMelody', 'PitchContoursMultiMelody', 'PitchFilter', 'PitchMelodia', 'PitchSalience', 'PitchSalienceFunction', 'PitchSalienceFunctionPeaks', 'PitchYin', 'PitchYinFFT', 'PitchYinProbabilistic', 'PitchYinProbabilities', 'PitchYinProbabilitiesHMM', 'PowerMean', 'PowerSpectrum', 'PredominantPitchMelodia', 'RMS', 'RawMoments', 'ReplayGain', 'Resample', 'ResampleFFT', 'RhythmDescriptors', 'RhythmExtractor', 'RhythmExtractor2013', 'RhythmTransform', 'RollOff', 'SNR', 'SaturationDetector', 'Scale', 'SineSubtraction', 'SingleBeatLoudness', 'Slicer', 'SpectralCentroidTime', 'SpectralComplexity', 'SpectralContrast', 'SpectralPeaks', 'SpectralWhitening', 'Spectrum', 'SpectrumCQ', 'SpectrumToCent', 'Spline', 'SprModelAnal', 'SprModelSynth', 'SpsModelAnal', 'SpsModelSynth', 'StartStopCut', 'StartStopSilence', 'StochasticModelAnal', 'StochasticModelSynth', 'StrongDecay', 'StrongPeak', 'SuperFluxExtractor', 'SuperFluxNovelty', 'SuperFluxPeaks', 'TCToTotal', 'TempoScaleBands', 'TempoTap', 'TempoTapDegara', 'TempoTapMaxAgreement', 'TempoTapTicks', 'TensorflowInputMusiCNN', 'TensorflowInputVGGish', 'TonalExtractor', 'TonicIndianArtMusic', 'TriangularBands', 'TriangularBarkBands', 'Trimmer', 'Tristimulus', 'TruePeakDetector', 'TuningFrequency', 'TuningFrequencyExtractor', 'UnaryOperator', 'UnaryOperatorStream', 'Variance', 'Vibrato', 'WarpedAutoCorrelation', 'Welch', 'Windowing', 'ZeroCrossingRate']"; - // class methods to call various essentia algorithms - val AfterMaxToBeforeMaxEnergyRatio(std::vector& input_pitch); - val AllPass(std::vector& input_signal, const float bandwidth=500, const float cutoffFrequency=1500, const int order=1, const float sampleRate=44100); - val AudioOnsetsMarker(std::vector& input_signal, const std::vector& onsets=std::vector(), const float sampleRate=44100, const std::string& type="beep"); - val AutoCorrelation(std::vector& input_array, const float frequencyDomainCompression=0.5, const bool generalized=false, const std::string& normalization="standard"); - val BFCC(std::vector& input_spectrum, const int dctType=2, const float highFrequencyBound=11000, const int inputSize=1025, const int liftering=0, const std::string& logType="dbamp", const float lowFrequencyBound=0, const std::string& normalize="unit_sum", const int numberBands=40, const int numberCoefficients=13, const float sampleRate=44100, const std::string& type="power", const std::string& weighting="warping"); - val BPF(float input_x, const std::vector& xPoints=std::vector{0, 1}, const std::vector& yPoints=std::vector{0, 1}); - val BandPass(std::vector& input_signal, const float bandwidth=500, const float cutoffFrequency=1500, const float sampleRate=44100); - val BandReject(std::vector& input_signal, const float bandwidth=500, const float cutoffFrequency=1500, const float sampleRate=44100); - val BarkBands(std::vector& input_spectrum, const int numberBands=27, const float sampleRate=44100); - val BeatTrackerDegara(std::vector& input_signal, const int maxTempo=208, const int minTempo=40); - val BeatTrackerMultiFeature(std::vector& input_signal, const int maxTempo=208, const int minTempo=40); - val Beatogram(std::vector& input_loudness, std::vector >& input_loudnessBandRatio, const int size=16); - val BeatsLoudness(std::vector& input_signal, const float beatDuration=0.05, const float beatWindowDuration=0.1, const std::vector& beats=std::vector(), const std::vector& frequencyBands=std::vector{20, 150, 400, 3200, 7000, 22000}, const float sampleRate=44100); - val BinaryOperator(std::vector& input_array1, std::vector& input_array2, const std::string& type="add"); - val BinaryOperatorStream(std::vector& input_array1, std::vector& input_array2, const std::string& type="add"); - val BpmHistogramDescriptors(std::vector& input_bpmIntervals); - val BpmRubato(std::vector& input_beats, const float longRegionsPruningTime=20, const float shortRegionsMergingTime=4, const float tolerance=0.08); - val CentralMoments(std::vector& input_array, const std::string& mode="pdf", const float range=1); - val Centroid(std::vector& input_array, const float range=1); - val ChordsDescriptors(std::vector input_chords, std::string input_key, std::string input_scale); - val ChordsDetection(std::vector >& input_pcp, const int hopSize=2048, const float sampleRate=44100, const float windowSize=2); - val ChordsDetectionBeats(std::vector >& input_pcp, std::vector& input_ticks, const std::string& chromaPick="interbeat_median", const int hopSize=2048, const float sampleRate=44100); - val ChromaCrossSimilarity(std::vector >& input_queryFeature, std::vector >& input_referenceFeature, const float binarizePercentile=0.095, const int frameStackSize=9, const int frameStackStride=1, const int noti=12, const bool oti=true, const bool otiBinary=false, const bool streaming=false); - val Chromagram(std::vector& input_frame, const int binsPerOctave=12, const float minFrequency=32.7, const int minimumKernelSize=4, const std::string& normalizeType="unit_max", const int numberBins=84, const float sampleRate=44100, const float scale=1, const float threshold=0.01, const std::string& windowType="hann", const bool zeroPhase=true); - val ClickDetector(std::vector& input_frame, const float detectionThreshold=30, const int frameSize=512, const int hopSize=256, const int order=12, const int powerEstimationThreshold=10, const float sampleRate=44100, const int silenceThreshold=-50); - val Clipper(std::vector& input_signal, const float max=1, const float min=-1); - val CoverSongSimilarity(std::vector >& input_inputArray, const std::string& alignmentType="serra09", const float disExtension=0.5, const float disOnset=0.5, const std::string& distanceType="asymmetric"); - val Crest(std::vector& input_array); - val CrossCorrelation(std::vector& input_arrayX, std::vector& input_arrayY, const int maxLag=1, const int minLag=0); - val CrossSimilarityMatrix(std::vector >& input_queryFeature, std::vector >& input_referenceFeature, const bool binarize=false, const float binarizePercentile=0.095, const int frameStackSize=1, const int frameStackStride=1); - val CubicSpline(float input_x, const int leftBoundaryFlag=0, const float leftBoundaryValue=0, const int rightBoundaryFlag=0, const float rightBoundaryValue=0, const std::vector& xPoints=std::vector{0, 1}, const std::vector& yPoints=std::vector{0, 1}); - val DCRemoval(std::vector& input_signal, const float cutoffFrequency=40, const float sampleRate=44100); - val DCT(std::vector& input_array, const int dctType=2, const int inputSize=10, const int liftering=0, const int outputSize=10); - val Danceability(std::vector& input_signal, const float maxTau=8800, const float minTau=310, const float sampleRate=44100, const float tauMultiplier=1.1); - val Decrease(std::vector& input_array, const float range=1); - val Derivative(std::vector& input_signal); - val DerivativeSFX(std::vector& input_envelope); - val DiscontinuityDetector(std::vector& input_frame, const float detectionThreshold=8, const float energyThreshold=-60, const int frameSize=512, const int hopSize=256, const int kernelSize=7, const int order=3, const int silenceThreshold=-50, const int subFrameSize=32); - val Dissonance(std::vector& input_frequencies, std::vector& input_magnitudes); - val DistributionShape(std::vector& input_centralMoments); - val Duration(std::vector& input_signal, const float sampleRate=44100); - val DynamicComplexity(std::vector& input_signal, const float frameSize=0.2, const float sampleRate=44100); - val ERBBands(std::vector& input_spectrum, const float highFrequencyBound=22050, const int inputSize=1025, const float lowFrequencyBound=50, const int numberBands=40, const float sampleRate=44100, const std::string& type="power", const float width=1); - val EffectiveDuration(std::vector& input_signal, const float sampleRate=44100, const float thresholdRatio=0.4); - val Energy(std::vector& input_array); - val EnergyBand(std::vector& input_spectrum, const float sampleRate=44100, const float startCutoffFrequency=0, const float stopCutoffFrequency=100); - val EnergyBandRatio(std::vector& input_spectrum, const float sampleRate=44100, const float startFrequency=0, const float stopFrequency=100); - val Entropy(std::vector& input_array); - val Envelope(std::vector& input_signal, const bool applyRectification=true, const float attackTime=10, const float releaseTime=1500, const float sampleRate=44100); - val EqualLoudness(std::vector& input_signal, const float sampleRate=44100); - val Flatness(std::vector& input_array); - val FlatnessDB(std::vector& input_array); - val FlatnessSFX(std::vector& input_envelope); - val Flux(std::vector& input_spectrum, const bool halfRectify=false, const std::string& norm="L2"); - val FrameCutter(std::vector& input_signal, const int frameSize=1024, const int hopSize=512, const bool lastFrameToEndOfFile=false, const bool startFromZero=false, const float validFrameThresholdRatio=0); - val FrameToReal(std::vector& input_signal, const int frameSize=2048, const int hopSize=128); - val FrequencyBands(std::vector& input_spectrum, const std::vector& frequencyBands=std::vector{0, 50, 100, 150, 200, 300, 400, 510, 630, 770, 920, 1080, 1270, 1480, 1720, 2000, 2320, 2700, 3150, 3700, 4400, 5300, 6400, 7700, 9500, 12000, 15500, 20500, 27000}, const float sampleRate=44100); - val GFCC(std::vector& input_spectrum, const int dctType=2, const float highFrequencyBound=22050, const int inputSize=1025, const std::string& logType="dbamp", const float lowFrequencyBound=40, const int numberBands=40, const int numberCoefficients=13, const float sampleRate=44100, const float silenceThreshold=1e-10, const std::string& type="power"); - val GapsDetector(std::vector& input_frame, const float attackTime=0.05, const int frameSize=2048, const int hopSize=1024, const int kernelSize=11, const float maximumTime=3500, const float minimumTime=10, const float postpowerTime=40, const float prepowerThreshold=-30, const float prepowerTime=40, const float releaseTime=0.05, const float sampleRate=44100, const float silenceThreshold=-50); - val GeometricMean(std::vector& input_array); - val HFC(std::vector& input_spectrum, const float sampleRate=44100, const std::string& type="Masri"); - val HPCP(std::vector& input_frequencies, std::vector& input_magnitudes, const bool bandPreset=true, const float bandSplitFrequency=500, const int harmonics=0, const float maxFrequency=5000, const bool maxShifted=false, const float minFrequency=40, const bool nonLinear=false, const std::string& normalized="unitMax", const float referenceFrequency=440, const float sampleRate=44100, const int size=12, const std::string& weightType="squaredCosine", const float windowSize=1); - val HarmonicBpm(std::vector& input_bpms, const int bpm=60, const float threshold=20, const float tolerance=5); - val HarmonicPeaks(std::vector& input_frequencies, std::vector& input_magnitudes, float input_pitch, const int maxHarmonics=20, const float tolerance=0.2); - val HighPass(std::vector& input_signal, const float cutoffFrequency=1500, const float sampleRate=44100); - val HighResolutionFeatures(std::vector& input_hpcp, const int maxPeaks=24); - val Histogram(std::vector& input_array, const float maxValue=1, const float minValue=0, const std::string& normalize="none", const int numberBins=10); - val HprModelAnal(std::vector& input_frame, float input_pitch, const int fftSize=2048, const int freqDevOffset=20, const float freqDevSlope=0.01, const float harmDevSlope=0.01, const int hopSize=512, const float magnitudeThreshold=0, const float maxFrequency=5000, const int maxPeaks=100, const int maxnSines=100, const float minFrequency=20, const int nHarmonics=100, const std::string& orderBy="frequency", const float sampleRate=44100, const float stocf=0.2); - val HpsModelAnal(std::vector& input_frame, float input_pitch, const int fftSize=2048, const int freqDevOffset=20, const float freqDevSlope=0.01, const float harmDevSlope=0.01, const int hopSize=512, const float magnitudeThreshold=0, const float maxFrequency=5000, const int maxPeaks=100, const int maxnSines=100, const float minFrequency=20, const int nHarmonics=100, const std::string& orderBy="frequency", const float sampleRate=44100, const float stocf=0.2); - val IDCT(std::vector& input_dct, const int dctType=2, const int inputSize=10, const int liftering=0, const int outputSize=10); - val IIR(std::vector& input_signal, const std::vector& denominator=std::vector{1}, const std::vector& numerator=std::vector{1}); - val Inharmonicity(std::vector& input_frequencies, std::vector& input_magnitudes); - val InstantPower(std::vector& input_array); - val Intensity(std::vector& input_signal, const float sampleRate=44100); - val Key(std::vector& input_pcp, const int numHarmonics=4, const int pcpSize=36, const std::string& profileType="bgate", const float slope=0.6, const bool useMajMin=false, const bool usePolyphony=true, const bool useThreeChords=true); - val KeyExtractor(std::vector& input_audio, const bool averageDetuningCorrection=true, const int frameSize=4096, const int hopSize=4096, const int hpcpSize=12, const float maxFrequency=3500, const int maximumSpectralPeaks=60, const float minFrequency=25, const float pcpThreshold=0.2, const std::string& profileType="bgate", const float sampleRate=44100, const float spectralPeaksThreshold=0.0001, const float tuningFrequency=440, const std::string& weightType="cosine", const std::string& windowType="hann"); - val LPC(std::vector& input_frame, const int order=10, const float sampleRate=44100, const std::string& type="regular"); - val Larm(std::vector& input_signal, const float attackTime=10, const float power=1.5, const float releaseTime=1500, const float sampleRate=44100); - val Leq(std::vector& input_signal); - val LevelExtractor(std::vector& input_signal, const int frameSize=88200, const int hopSize=44100); - val LogAttackTime(std::vector& input_signal, const float sampleRate=44100, const float startAttackThreshold=0.2, const float stopAttackThreshold=0.9); - val LogSpectrum(std::vector& input_spectrum, const float binsPerSemitone=3, const int frameSize=1025, const float rollOn=0, const float sampleRate=44100); - val LoopBpmConfidence(std::vector& input_signal, float input_bpmEstimate, const float sampleRate=44100); - val LoopBpmEstimator(std::vector& input_signal, const float confidenceThreshold=0.95); - val Loudness(std::vector& input_signal); - val LoudnessVickers(std::vector& input_signal, const float sampleRate=44100); - val LowLevelSpectralEqloudExtractor(std::vector& input_signal, const int frameSize=2048, const int hopSize=1024, const float sampleRate=44100); - val LowLevelSpectralExtractor(std::vector& input_signal, const int frameSize=2048, const int hopSize=1024, const float sampleRate=44100); - val LowPass(std::vector& input_signal, const float cutoffFrequency=1500, const float sampleRate=44100); - val MFCC(std::vector& input_spectrum, const int dctType=2, const float highFrequencyBound=11000, const int inputSize=1025, const int liftering=0, const std::string& logType="dbamp", const float lowFrequencyBound=0, const std::string& normalize="unit_sum", const int numberBands=40, const int numberCoefficients=13, const float sampleRate=44100, const float silenceThreshold=1e-10, const std::string& type="power", const std::string& warpingFormula="htkMel", const std::string& weighting="warping"); - val MaxFilter(std::vector& input_signal, const bool causal=true, const int width=3); - val MaxMagFreq(std::vector& input_spectrum, const float sampleRate=44100); - val MaxToTotal(std::vector& input_envelope); - val Mean(std::vector& input_array); - val Median(std::vector& input_array); - val MedianFilter(std::vector& input_array, const int kernelSize=11); - val MelBands(std::vector& input_spectrum, const float highFrequencyBound=22050, const int inputSize=1025, const bool log=false, const float lowFrequencyBound=0, const std::string& normalize="unit_sum", const int numberBands=24, const float sampleRate=44100, const std::string& type="power", const std::string& warpingFormula="htkMel", const std::string& weighting="warping"); - val Meter(std::vector >& input_beatogram); - val MinMax(std::vector& input_array, const std::string& type="min"); - val MinToTotal(std::vector& input_envelope); - val MovingAverage(std::vector& input_signal, const int size=6); - val MultiPitchKlapuri(std::vector& input_signal, const float binResolution=10, const int frameSize=2048, const float harmonicWeight=0.8, const int hopSize=128, const float magnitudeCompression=1, const int magnitudeThreshold=40, const float maxFrequency=1760, const float minFrequency=80, const int numberHarmonics=10, const float referenceFrequency=55, const float sampleRate=44100); - val MultiPitchMelodia(std::vector& input_signal, const float binResolution=10, const int filterIterations=3, const int frameSize=2048, const bool guessUnvoiced=false, const float harmonicWeight=0.8, const int hopSize=128, const float magnitudeCompression=1, const int magnitudeThreshold=40, const float maxFrequency=20000, const int minDuration=100, const float minFrequency=40, const int numberHarmonics=20, const float peakDistributionThreshold=0.9, const float peakFrameThreshold=0.9, const float pitchContinuity=27.5625, const float referenceFrequency=55, const float sampleRate=44100, const int timeContinuity=100); - val Multiplexer(const int numberRealInputs=0, const int numberVectorRealInputs=0); - val NNLSChroma(std::vector >& input_logSpectrogram, std::vector& input_meanTuning, std::vector& input_localTuning, const std::string& chromaNormalization="none", const int frameSize=1025, const float sampleRate=44100, const float spectralShape=0.7, const float spectralWhitening=1, const std::string& tuningMode="global", const bool useNNLS=true); - val NoiseAdder(std::vector& input_signal, const bool fixSeed=false, const int level=-100); - val NoiseBurstDetector(std::vector& input_frame, const float alpha=0.9, const int silenceThreshold=-50, const int threshold=8); - val NoveltyCurve(std::vector >& input_frequencyBands, const float frameRate=344.531, const bool normalize=false, const std::vector& weightCurve=std::vector(), const std::string& weightCurveType="hybrid"); - val NoveltyCurveFixedBpmEstimator(std::vector& input_novelty, const int hopSize=512, const float maxBpm=560, const float minBpm=30, const float sampleRate=44100, const float tolerance=3); - val OddToEvenHarmonicEnergyRatio(std::vector& input_frequencies, std::vector& input_magnitudes); - val OnsetDetection(std::vector& input_spectrum, std::vector& input_phase, const std::string& method="hfc", const float sampleRate=44100); - val OnsetDetectionGlobal(std::vector& input_signal, const int frameSize=2048, const int hopSize=512, const std::string& method="infogain", const float sampleRate=44100); - val OnsetRate(std::vector& input_signal); - val OverlapAdd(std::vector& input_signal, const int frameSize=2048, const float gain=1, const int hopSize=128); - val PeakDetection(std::vector& input_array, const bool interpolate=true, const int maxPeaks=100, const float maxPosition=1, const float minPeakDistance=0, const float minPosition=0, const std::string& orderBy="position", const float range=1, const float threshold=-1e+06); - val PercivalBpmEstimator(std::vector& input_signal, const int frameSize=1024, const int frameSizeOSS=2048, const int hopSize=128, const int hopSizeOSS=128, const int maxBPM=210, const int minBPM=50, const int sampleRate=44100); - val PercivalEnhanceHarmonics(std::vector& input_array); - val PercivalEvaluatePulseTrains(std::vector& input_oss, std::vector& input_positions); - val PitchContourSegmentation(std::vector& input_pitch, std::vector& input_signal, const int hopSize=128, const float minDuration=0.1, const int pitchDistanceThreshold=60, const int rmsThreshold=-2, const int sampleRate=44100, const int tuningFrequency=440); - val PitchContours(std::vector >& input_peakBins, std::vector >& input_peakSaliences, const float binResolution=10, const int hopSize=128, const float minDuration=100, const float peakDistributionThreshold=0.9, const float peakFrameThreshold=0.9, const float pitchContinuity=27.5625, const float sampleRate=44100, const float timeContinuity=100); - val PitchContoursMelody(std::vector >& input_contoursBins, std::vector >& input_contoursSaliences, std::vector& input_contoursStartTimes, float input_duration, const float binResolution=10, const int filterIterations=3, const bool guessUnvoiced=false, const int hopSize=128, const float maxFrequency=20000, const float minFrequency=80, const float referenceFrequency=55, const float sampleRate=44100, const bool voiceVibrato=false, const float voicingTolerance=0.2); - val PitchContoursMonoMelody(std::vector >& input_contoursBins, std::vector >& input_contoursSaliences, std::vector& input_contoursStartTimes, float input_duration, const float binResolution=10, const int filterIterations=3, const bool guessUnvoiced=false, const int hopSize=128, const float maxFrequency=20000, const float minFrequency=80, const float referenceFrequency=55, const float sampleRate=44100); - val PitchContoursMultiMelody(std::vector >& input_contoursBins, std::vector >& input_contoursSaliences, std::vector& input_contoursStartTimes, float input_duration, const float binResolution=10, const int filterIterations=3, const bool guessUnvoiced=false, const int hopSize=128, const float maxFrequency=20000, const float minFrequency=80, const float referenceFrequency=55, const float sampleRate=44100); - val PitchFilter(std::vector& input_pitch, std::vector& input_pitchConfidence, const int confidenceThreshold=36, const int minChunkSize=30, const bool useAbsolutePitchConfidence=false); - val PitchMelodia(std::vector& input_signal, const float binResolution=10, const int filterIterations=3, const int frameSize=2048, const bool guessUnvoiced=false, const float harmonicWeight=0.8, const int hopSize=128, const float magnitudeCompression=1, const int magnitudeThreshold=40, const float maxFrequency=20000, const int minDuration=100, const float minFrequency=40, const int numberHarmonics=20, const float peakDistributionThreshold=0.9, const float peakFrameThreshold=0.9, const float pitchContinuity=27.5625, const float referenceFrequency=55, const float sampleRate=44100, const int timeContinuity=100); - val PitchSalience(std::vector& input_spectrum, const float highBoundary=5000, const float lowBoundary=100, const float sampleRate=44100); - val PitchSalienceFunction(std::vector& input_frequencies, std::vector& input_magnitudes, const float binResolution=10, const float harmonicWeight=0.8, const float magnitudeCompression=1, const float magnitudeThreshold=40, const int numberHarmonics=20, const float referenceFrequency=55); - val PitchSalienceFunctionPeaks(std::vector& input_salienceFunction, const float binResolution=10, const float maxFrequency=1760, const float minFrequency=55, const float referenceFrequency=55); - val PitchYin(std::vector& input_signal, const int frameSize=2048, const bool interpolate=true, const float maxFrequency=22050, const float minFrequency=20, const float sampleRate=44100, const float tolerance=0.15); - val PitchYinFFT(std::vector& input_spectrum, const int frameSize=2048, const bool interpolate=true, const float maxFrequency=22050, const float minFrequency=20, const float sampleRate=44100, const float tolerance=1); - val PitchYinProbabilistic(std::vector& input_signal, const int frameSize=2048, const int hopSize=256, const float lowRMSThreshold=0.1, const std::string& outputUnvoiced="negative", const bool preciseTime=false, const float sampleRate=44100); - val PitchYinProbabilities(std::vector& input_signal, const int frameSize=2048, const float lowAmp=0.1, const bool preciseTime=false, const float sampleRate=44100); - val PitchYinProbabilitiesHMM(std::vector >& input_pitchCandidates, std::vector >& input_probabilities, const float minFrequency=61.735, const int numberBinsPerSemitone=5, const float selfTransition=0.99, const float yinTrust=0.5); - val PowerMean(std::vector& input_array, const float power=1); - val PowerSpectrum(std::vector& input_signal, const int size=2048); - val PredominantPitchMelodia(std::vector& input_signal, const float binResolution=10, const int filterIterations=3, const int frameSize=2048, const bool guessUnvoiced=false, const float harmonicWeight=0.8, const int hopSize=128, const float magnitudeCompression=1, const int magnitudeThreshold=40, const float maxFrequency=20000, const int minDuration=100, const float minFrequency=80, const int numberHarmonics=20, const float peakDistributionThreshold=0.9, const float peakFrameThreshold=0.9, const float pitchContinuity=27.5625, const float referenceFrequency=55, const float sampleRate=44100, const int timeContinuity=100, const bool voiceVibrato=false, const float voicingTolerance=0.2); - val RMS(std::vector& input_array); - val RawMoments(std::vector& input_array, const float range=22050); - val ReplayGain(std::vector& input_signal, const float sampleRate=44100); - val Resample(std::vector& input_signal, const float inputSampleRate=44100, const float outputSampleRate=44100, const int quality=1); - val ResampleFFT(std::vector& input_input, const int inSize=128, const int outSize=128); - val RhythmDescriptors(std::vector& input_signal); - val RhythmExtractor(std::vector& input_signal, const int frameHop=1024, const int frameSize=1024, const int hopSize=256, const float lastBeatInterval=0.1, const int maxTempo=208, const int minTempo=40, const int numberFrames=1024, const float sampleRate=44100, const std::vector& tempoHints=std::vector(), const float tolerance=0.24, const bool useBands=true, const bool useOnset=true); - val RhythmExtractor2013(std::vector& input_signal, const int maxTempo=208, const std::string& method="multifeature", const int minTempo=40); - val RhythmTransform(std::vector >& input_melBands, const int frameSize=256, const int hopSize=32); - val RollOff(std::vector& input_spectrum, const float cutoff=0.85, const float sampleRate=44100); - val SNR(std::vector& input_frame, const float MAAlpha=0.95, const float MMSEAlpha=0.98, const float NoiseAlpha=0.9, const int frameSize=512, const float noiseThreshold=-40, const float sampleRate=44100, const bool useBroadbadNoiseCorrection=true); - val SaturationDetector(std::vector& input_frame, const float differentialThreshold=0.001, const float energyThreshold=-1, const int frameSize=512, const int hopSize=256, const float minimumDuration=0.005, const float sampleRate=44100); - val Scale(std::vector& input_signal, const bool clipping=true, const float factor=10, const float maxAbsValue=1); - val SineSubtraction(std::vector& input_frame, std::vector& input_magnitudes, std::vector& input_frequencies, std::vector& input_phases, const int fftSize=512, const int hopSize=128, const float sampleRate=44100); - val SingleBeatLoudness(std::vector& input_beat, const float beatDuration=0.05, const float beatWindowDuration=0.1, const std::vector& frequencyBands=std::vector{0, 200, 400, 800, 1600, 3200, 22000}, const std::string& onsetStart="sumEnergy", const float sampleRate=44100); - val Slicer(std::vector& input_audio, const std::vector& endTimes=std::vector(), const float sampleRate=44100, const std::vector& startTimes=std::vector(), const std::string& timeUnits="seconds"); - val SpectralCentroidTime(std::vector& input_array, const float sampleRate=44100); - val SpectralComplexity(std::vector& input_spectrum, const float magnitudeThreshold=0.005, const float sampleRate=44100); - val SpectralContrast(std::vector& input_spectrum, const int frameSize=2048, const float highFrequencyBound=11000, const float lowFrequencyBound=20, const float neighbourRatio=0.4, const int numberBands=6, const float sampleRate=22050, const float staticDistribution=0.15); - val SpectralPeaks(std::vector& input_spectrum, const float magnitudeThreshold=0, const float maxFrequency=5000, const int maxPeaks=100, const float minFrequency=0, const std::string& orderBy="frequency", const float sampleRate=44100); - val SpectralWhitening(std::vector& input_spectrum, std::vector& input_frequencies, std::vector& input_magnitudes, const float maxFrequency=5000, const float sampleRate=44100); - val Spectrum(std::vector& input_frame, const int size=2048); - val SpectrumCQ(std::vector& input_frame, const int binsPerOctave=12, const float minFrequency=32.7, const int minimumKernelSize=4, const int numberBins=84, const float sampleRate=44100, const float scale=1, const float threshold=0.01, const std::string& windowType="hann", const bool zeroPhase=true); - val SpectrumToCent(std::vector& input_spectrum, const int bands=720, const float centBinResolution=10, const int inputSize=32768, const bool log=true, const float minimumFrequency=164, const std::string& normalize="unit_sum", const float sampleRate=44100, const std::string& type="power"); - val Spline(float input_x, const float beta1=1, const float beta2=0, const std::string& type="b", const std::vector& xPoints=std::vector{0, 1}, const std::vector& yPoints=std::vector{0, 1}); - val SprModelAnal(std::vector& input_frame, const int fftSize=2048, const int freqDevOffset=20, const float freqDevSlope=0.01, const int hopSize=512, const float magnitudeThreshold=0, const float maxFrequency=5000, const int maxPeaks=100, const int maxnSines=100, const float minFrequency=0, const std::string& orderBy="frequency", const float sampleRate=44100); - val SprModelSynth(std::vector& input_magnitudes, std::vector& input_frequencies, std::vector& input_phases, std::vector& input_res, const int fftSize=2048, const int hopSize=512, const float sampleRate=44100); - val SpsModelAnal(std::vector& input_frame, const int fftSize=2048, const int freqDevOffset=20, const float freqDevSlope=0.01, const int hopSize=512, const float magnitudeThreshold=0, const float maxFrequency=5000, const int maxPeaks=100, const int maxnSines=100, const float minFrequency=0, const std::string& orderBy="frequency", const float sampleRate=44100, const float stocf=0.2); - val SpsModelSynth(std::vector& input_magnitudes, std::vector& input_frequencies, std::vector& input_phases, std::vector& input_stocenv, const int fftSize=2048, const int hopSize=512, const float sampleRate=44100, const float stocf=0.2); - val StartStopCut(std::vector& input_audio, const int frameSize=256, const int hopSize=256, const float maximumStartTime=10, const float maximumStopTime=10, const float sampleRate=44100, const int threshold=-60); - val StartStopSilence(std::vector& input_frame, const int threshold=-60); - val StochasticModelAnal(std::vector& input_frame, const int fftSize=2048, const int hopSize=512, const float sampleRate=44100, const float stocf=0.2); - val StochasticModelSynth(std::vector& input_stocenv, const int fftSize=2048, const int hopSize=512, const float sampleRate=44100, const float stocf=0.2); - val StrongDecay(std::vector& input_signal, const float sampleRate=44100); - val StrongPeak(std::vector& input_spectrum); - val SuperFluxExtractor(std::vector& input_signal, const float combine=20, const int frameSize=2048, const int hopSize=256, const float ratioThreshold=16, const float sampleRate=44100, const float threshold=0.05); - val SuperFluxNovelty(std::vector >& input_bands, const int binWidth=3, const int frameWidth=2); - val SuperFluxPeaks(std::vector& input_novelty, const float combine=30, const float frameRate=172, const float pre_avg=100, const float pre_max=30, const float ratioThreshold=16, const float threshold=0.05); - val TCToTotal(std::vector& input_envelope); - val TempoScaleBands(std::vector& input_bands, const std::vector& bandsGain=std::vector{2, 3, 2, 1, 1.20000004768, 2, 3, 2.5}, const float frameTime=512); - val TempoTap(std::vector& input_featuresFrame, const int frameHop=1024, const int frameSize=256, const int maxTempo=208, const int minTempo=40, const int numberFrames=1024, const float sampleRate=44100, const std::vector& tempoHints=std::vector()); - val TempoTapDegara(std::vector& input_onsetDetections, const int maxTempo=208, const int minTempo=40, const std::string& resample="none", const float sampleRateODF=86.1328); - val TempoTapMaxAgreement(std::vector >& input_tickCandidates); - val TempoTapTicks(std::vector& input_periods, std::vector& input_phases, const int frameHop=512, const int hopSize=256, const float sampleRate=44100); - val TensorflowInputMusiCNN(std::vector& input_frame); - val TensorflowInputVGGish(std::vector& input_frame); - val TonalExtractor(std::vector& input_signal, const int frameSize=4096, const int hopSize=2048, const float tuningFrequency=440); - val TonicIndianArtMusic(std::vector& input_signal, const float binResolution=10, const int frameSize=2048, const float harmonicWeight=0.85, const int hopSize=512, const float magnitudeCompression=1, const float magnitudeThreshold=40, const float maxTonicFrequency=375, const float minTonicFrequency=100, const int numberHarmonics=20, const int numberSaliencePeaks=5, const float referenceFrequency=55, const float sampleRate=44100); - val TriangularBands(std::vector& input_spectrum, const std::vector& frequencyBands=std::vector{21.533203125, 43.06640625, 64.599609375, 86.1328125, 107.666015625, 129.19921875, 150.732421875, 172.265625, 193.798828125, 215.33203125, 236.865234375, 258.3984375, 279.931640625, 301.46484375, 322.998046875, 344.53125, 366.064453125, 387.59765625, 409.130859375, 430.6640625, 452.197265625, 473.73046875, 495.263671875, 516.796875, 538.330078125, 559.86328125, 581.396484375, 602.9296875, 624.462890625, 645.99609375, 667.529296875, 689.0625, 710.595703125, 732.12890625, 753.662109375, 775.1953125, 796.728515625, 839.794921875, 861.328125, 882.861328125, 904.39453125, 925.927734375, 968.994140625, 990.52734375, 1012.06054688, 1055.12695312, 1076.66015625, 1098.19335938, 1141.25976562, 1184.32617188, 1205.859375, 1248.92578125, 1270.45898438, 1313.52539062, 1356.59179688, 1399.65820312, 1442.72460938, 1485.79101562, 1528.85742188, 1571.92382812, 1614.99023438, 1658.05664062, 1701.12304688, 1765.72265625, 1808.7890625, 1873.38867188, 1916.45507812, 1981.0546875, 2024.12109375, 2088.72070312, 2153.3203125, 2217.91992188, 2282.51953125, 2347.11914062, 2411.71875, 2497.8515625, 2562.45117188, 2627.05078125, 2713.18359375, 2799.31640625, 2885.44921875, 2950.04882812, 3036.18164062, 3143.84765625, 3229.98046875, 3316.11328125, 3423.77929688, 3509.91210938, 3617.578125, 3725.24414062, 3832.91015625, 3940.57617188, 4069.77539062, 4177.44140625, 4306.640625, 4435.83984375, 4565.0390625, 4694.23828125, 4844.97070312, 4974.16992188, 5124.90234375, 5275.63476562, 5426.3671875, 5577.09960938, 5749.36523438, 5921.63085938, 6093.89648438, 6266.16210938, 6459.9609375, 6653.75976562, 6847.55859375, 7041.35742188, 7256.68945312, 7450.48828125, 7687.35351562, 7902.68554688, 8139.55078125, 8376.41601562, 8613.28125, 8871.6796875, 9130.078125, 9388.4765625, 9668.40820312, 9948.33984375, 10249.8046875, 10551.2695312, 10852.734375, 11175.7324219, 11498.7304688, 11843.2617188, 12187.7929688, 12553.8574219, 12919.921875, 13285.9863281, 13673.5839844, 14082.7148438, 14491.8457031, 14922.5097656, 15353.1738281, 15805.3710938, 16257.5683594}, const int inputSize=1025, const bool log=true, const std::string& normalize="unit_sum", const float sampleRate=44100, const std::string& type="power", const std::string& weighting="linear"); - val TriangularBarkBands(std::vector& input_spectrum, const float highFrequencyBound=22050, const int inputSize=1025, const bool log=false, const float lowFrequencyBound=0, const std::string& normalize="unit_sum", const int numberBands=24, const float sampleRate=44100, const std::string& type="power", const std::string& weighting="warping"); - val Trimmer(std::vector& input_signal, const bool checkRange=false, const float endTime=1e+06, const float sampleRate=44100, const float startTime=0); - val Tristimulus(std::vector& input_frequencies, std::vector& input_magnitudes); - val TruePeakDetector(std::vector& input_signal, const bool blockDC=false, const bool emphasise=false, const int oversamplingFactor=4, const int quality=1, const float sampleRate=44100, const float threshold=-0.0002, const int version=4); - val TuningFrequency(std::vector& input_frequencies, std::vector& input_magnitudes, const float resolution=1); - val TuningFrequencyExtractor(std::vector& input_signal, const int frameSize=4096, const int hopSize=2048); - val UnaryOperator(std::vector& input_array, const float scale=1, const float shift=0, const std::string& type="identity"); - val UnaryOperatorStream(std::vector& input_array, const float scale=1, const float shift=0, const std::string& type="identity"); - val Variance(std::vector& input_array); - val Vibrato(std::vector& input_pitch, const float maxExtend=250, const float maxFrequency=8, const float minExtend=50, const float minFrequency=4, const float sampleRate=344.531); - val WarpedAutoCorrelation(std::vector& input_array, const int maxLag=1, const float sampleRate=44100); - val Welch(std::vector& input_frame, const int averagingFrames=10, const int fftSize=1024, const int frameSize=512, const float sampleRate=44100, const std::string& scaling="density", const std::string& windowType="hann"); - val Windowing(std::vector& input_frame, const bool normalized=true, const int size=1024, const std::string& type="hann", const int zeroPadding=0, const bool zeroPhase=true); - val ZeroCrossingRate(std::vector& input_signal, const float threshold=0); + FrameGenerator(int frameSize, int hopSize); + ~FrameGenerator(); + void configure(int frameSize, int hopSize); + std::vector< std::vector > compute(const val& signalArray); + void reset(); + private: + Algorithm* _framecutter; +}; + +// val MonoMixer(std::vector& left_channel, std::vector& right_channel); +// val LoudnessEBUR128(std::vector& left_channel, std::vector& right_channel, const float hopSize=0.1, const float sampleRate=44100, const bool startAtZero=false); +// NOTE: The following code snippets are machine generated. Do not edit. + +// class property which stores all the list of essentia algorithm names available in essentia.js +std::string algorithmNames = "['AfterMaxToBeforeMaxEnergyRatio', 'AllPass', 'AudioOnsetsMarker', 'AutoCorrelation', 'BFCC', 'BPF', 'BandPass', 'BandReject', 'BarkBands', 'BeatTrackerDegara', 'BeatTrackerMultiFeature', 'Beatogram', 'BeatsLoudness', 'BinaryOperator', 'BinaryOperatorStream', 'BpmHistogramDescriptors', 'BpmRubato', 'CentralMoments', 'Centroid', 'ChordsDescriptors', 'ChordsDetection', 'ChordsDetectionBeats', 'ChromaCrossSimilarity', 'Chromagram', 'ClickDetector', 'Clipper', 'CoverSongSimilarity', 'Crest', 'CrossCorrelation', 'CrossSimilarityMatrix', 'CubicSpline', 'DCRemoval', 'DCT', 'Danceability', 'Decrease', 'Derivative', 'DerivativeSFX', 'DiscontinuityDetector', 'Dissonance', 'DistributionShape', 'Duration', 'DynamicComplexity', 'ERBBands', 'EffectiveDuration', 'Energy', 'EnergyBand', 'EnergyBandRatio', 'Entropy', 'Envelope', 'EqualLoudness', 'Flatness', 'FlatnessDB', 'FlatnessSFX', 'Flux', 'FrameCutter', 'FrameToReal', 'FrequencyBands', 'GFCC', 'GapsDetector', 'GeometricMean', 'HFC', 'HPCP', 'HarmonicBpm', 'HarmonicPeaks', 'HighPass', 'HighResolutionFeatures', 'Histogram', 'HprModelAnal', 'HpsModelAnal', 'IDCT', 'IIR', 'Inharmonicity', 'InstantPower', 'Intensity', 'Key', 'KeyExtractor', 'LPC', 'Larm', 'Leq', 'LevelExtractor', 'LogAttackTime', 'LogSpectrum', 'LoopBpmConfidence', 'LoopBpmEstimator', 'Loudness', 'LoudnessVickers', 'LowLevelSpectralEqloudExtractor', 'LowLevelSpectralExtractor', 'LowPass', 'MFCC', 'MaxFilter', 'MaxMagFreq', 'MaxToTotal', 'Mean', 'Median', 'MedianFilter', 'MelBands', 'Meter', 'MinMax', 'MinToTotal', 'MovingAverage', 'MultiPitchKlapuri', 'MultiPitchMelodia', 'Multiplexer', 'NNLSChroma', 'NoiseAdder', 'NoiseBurstDetector', 'NoveltyCurve', 'NoveltyCurveFixedBpmEstimator', 'OddToEvenHarmonicEnergyRatio', 'OnsetDetection', 'OnsetDetectionGlobal', 'OnsetRate', 'OverlapAdd', 'PeakDetection', 'PercivalBpmEstimator', 'PercivalEnhanceHarmonics', 'PercivalEvaluatePulseTrains', 'PitchContourSegmentation', 'PitchContours', 'PitchContoursMelody', 'PitchContoursMonoMelody', 'PitchContoursMultiMelody', 'PitchFilter', 'PitchMelodia', 'PitchSalience', 'PitchSalienceFunction', 'PitchSalienceFunctionPeaks', 'PitchYin', 'PitchYinFFT', 'PitchYinProbabilistic', 'PitchYinProbabilities', 'PitchYinProbabilitiesHMM', 'PowerMean', 'PowerSpectrum', 'PredominantPitchMelodia', 'RMS', 'RawMoments', 'ReplayGain', 'Resample', 'ResampleFFT', 'RhythmDescriptors', 'RhythmExtractor', 'RhythmExtractor2013', 'RhythmTransform', 'RollOff', 'SNR', 'SaturationDetector', 'Scale', 'SineSubtraction', 'SingleBeatLoudness', 'Slicer', 'SpectralCentroidTime', 'SpectralComplexity', 'SpectralContrast', 'SpectralPeaks', 'SpectralWhitening', 'Spectrum', 'SpectrumCQ', 'SpectrumToCent', 'Spline', 'SprModelAnal', 'SprModelSynth', 'SpsModelAnal', 'SpsModelSynth', 'StartStopCut', 'StartStopSilence', 'StochasticModelAnal', 'StochasticModelSynth', 'StrongDecay', 'StrongPeak', 'SuperFluxExtractor', 'SuperFluxNovelty', 'SuperFluxPeaks', 'TCToTotal', 'TempoScaleBands', 'TempoTap', 'TempoTapDegara', 'TempoTapMaxAgreement', 'TempoTapTicks', 'TensorflowInputFSDSINet', 'TensorflowInputMusiCNN', 'TensorflowInputTempoCNN', 'TensorflowInputVGGish', 'TonalExtractor', 'TonicIndianArtMusic', 'TriangularBands', 'TriangularBarkBands', 'Trimmer', 'Tristimulus', 'TruePeakDetector', 'TuningFrequency', 'TuningFrequencyExtractor', 'UnaryOperator', 'UnaryOperatorStream', 'Variance', 'Vibrato', 'WarpedAutoCorrelation', 'Welch', 'Windowing', 'ZeroCrossingRate']"; +// class methods to call various essentia algorithms + +class AfterMaxToBeforeMaxEnergyRatio { + public: + AfterMaxToBeforeMaxEnergyRatio(); + ~AfterMaxToBeforeMaxEnergyRatio(); + void configure(); + val compute(std::vector& input_pitch); + void reset(); + private: + Algorithm* _aftermaxtobeforemaxenergyratio; +}; + +class AllPass { + public: + AllPass(const float bandwidth=500, const float cutoffFrequency=1500, const int order=1, const float sampleRate=44100); + ~AllPass(); + void configure(const float bandwidth=500, const float cutoffFrequency=1500, const int order=1, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _allpass; +}; + +class AudioOnsetsMarker { + public: + AudioOnsetsMarker(const std::vector& onsets=std::vector(), const float sampleRate=44100, const std::string& type="beep"); + ~AudioOnsetsMarker(); + void configure(const std::vector& onsets=std::vector(), const float sampleRate=44100, const std::string& type="beep"); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _audioonsetsmarker; +}; + +class AutoCorrelation { + public: + AutoCorrelation(const float frequencyDomainCompression=0.5, const bool generalized=false, const std::string& normalization="standard"); + ~AutoCorrelation(); + void configure(const float frequencyDomainCompression=0.5, const bool generalized=false, const std::string& normalization="standard"); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _autocorrelation; +}; + +class BFCC { + public: + BFCC(const int dctType=2, const float highFrequencyBound=11000, const int inputSize=1025, const int liftering=0, const std::string& logType="dbamp", const float lowFrequencyBound=0, const std::string& normalize="unit_sum", const int numberBands=40, const int numberCoefficients=13, const float sampleRate=44100, const std::string& type="power", const std::string& weighting="warping"); + ~BFCC(); + void configure(const int dctType=2, const float highFrequencyBound=11000, const int inputSize=1025, const int liftering=0, const std::string& logType="dbamp", const float lowFrequencyBound=0, const std::string& normalize="unit_sum", const int numberBands=40, const int numberCoefficients=13, const float sampleRate=44100, const std::string& type="power", const std::string& weighting="warping"); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _bfcc; +}; + +class BPF { + public: + BPF(const std::vector& xPoints=std::vector{0, 1}, const std::vector& yPoints=std::vector{0, 1}); + ~BPF(); + void configure(const std::vector& xPoints=std::vector{0, 1}, const std::vector& yPoints=std::vector{0, 1}); + val compute(float input_x); + void reset(); + private: + Algorithm* _bpf; +}; + +class BandPass { + public: + BandPass(const float bandwidth=500, const float cutoffFrequency=1500, const float sampleRate=44100); + ~BandPass(); + void configure(const float bandwidth=500, const float cutoffFrequency=1500, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _bandpass; +}; + +class BandReject { + public: + BandReject(const float bandwidth=500, const float cutoffFrequency=1500, const float sampleRate=44100); + ~BandReject(); + void configure(const float bandwidth=500, const float cutoffFrequency=1500, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _bandreject; +}; + +class BarkBands { + public: + BarkBands(const int numberBands=27, const float sampleRate=44100); + ~BarkBands(); + void configure(const int numberBands=27, const float sampleRate=44100); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _barkbands; +}; + +class BeatTrackerDegara { + public: + BeatTrackerDegara(const int maxTempo=208, const int minTempo=40); + ~BeatTrackerDegara(); + void configure(const int maxTempo=208, const int minTempo=40); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _beattrackerdegara; +}; + +class BeatTrackerMultiFeature { + public: + BeatTrackerMultiFeature(const int maxTempo=208, const int minTempo=40); + ~BeatTrackerMultiFeature(); + void configure(const int maxTempo=208, const int minTempo=40); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _beattrackermultifeature; +}; + +class Beatogram { + public: + Beatogram(const int size=16); + ~Beatogram(); + void configure(const int size=16); + val compute(std::vector& input_loudness, std::vector >& input_loudnessBandRatio); + void reset(); + private: + Algorithm* _beatogram; +}; + +class BeatsLoudness { + public: + BeatsLoudness(const float beatDuration=0.05, const float beatWindowDuration=0.1, const std::vector& beats=std::vector(), const std::vector& frequencyBands=std::vector{20, 150, 400, 3200, 7000, 22000}, const float sampleRate=44100); + ~BeatsLoudness(); + void configure(const float beatDuration=0.05, const float beatWindowDuration=0.1, const std::vector& beats=std::vector(), const std::vector& frequencyBands=std::vector{20, 150, 400, 3200, 7000, 22000}, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _beatsloudness; +}; + +class BinaryOperator { + public: + BinaryOperator(const std::string& type="add"); + ~BinaryOperator(); + void configure(const std::string& type="add"); + val compute(std::vector& input_array1, std::vector& input_array2); + void reset(); + private: + Algorithm* _binaryoperator; +}; + +class BinaryOperatorStream { + public: + BinaryOperatorStream(const std::string& type="add"); + ~BinaryOperatorStream(); + void configure(const std::string& type="add"); + val compute(std::vector& input_array1, std::vector& input_array2); + void reset(); + private: + Algorithm* _binaryoperatorstream; +}; + +class BpmHistogramDescriptors { + public: + BpmHistogramDescriptors(); + ~BpmHistogramDescriptors(); + void configure(); + val compute(std::vector& input_bpmIntervals); + void reset(); + private: + Algorithm* _bpmhistogramdescriptors; +}; + +class BpmRubato { + public: + BpmRubato(const float longRegionsPruningTime=20, const float shortRegionsMergingTime=4, const float tolerance=0.08); + ~BpmRubato(); + void configure(const float longRegionsPruningTime=20, const float shortRegionsMergingTime=4, const float tolerance=0.08); + val compute(std::vector& input_beats); + void reset(); + private: + Algorithm* _bpmrubato; +}; + +class CentralMoments { + public: + CentralMoments(const std::string& mode="pdf", const float range=1); + ~CentralMoments(); + void configure(const std::string& mode="pdf", const float range=1); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _centralmoments; +}; + +class Centroid { + public: + Centroid(const float range=1); + ~Centroid(); + void configure(const float range=1); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _centroid; +}; + +class ChordsDescriptors { + public: + ChordsDescriptors(); + ~ChordsDescriptors(); + void configure(); + val compute(std::vector input_chords, std::string input_key, std::string input_scale); + void reset(); + private: + Algorithm* _chordsdescriptors; +}; + +class ChordsDetection { + public: + ChordsDetection(const int hopSize=2048, const float sampleRate=44100, const float windowSize=2); + ~ChordsDetection(); + void configure(const int hopSize=2048, const float sampleRate=44100, const float windowSize=2); + val compute(std::vector >& input_pcp); + void reset(); + private: + Algorithm* _chordsdetection; +}; + +class ChordsDetectionBeats { + public: + ChordsDetectionBeats(const std::string& chromaPick="interbeat_median", const int hopSize=2048, const float sampleRate=44100); + ~ChordsDetectionBeats(); + void configure(const std::string& chromaPick="interbeat_median", const int hopSize=2048, const float sampleRate=44100); + val compute(std::vector >& input_pcp, std::vector& input_ticks); + void reset(); + private: + Algorithm* _chordsdetectionbeats; +}; + +class ChromaCrossSimilarity { + public: + ChromaCrossSimilarity(const float binarizePercentile=0.095, const int frameStackSize=9, const int frameStackStride=1, const int noti=12, const bool oti=true, const bool otiBinary=false, const bool streaming=false); + ~ChromaCrossSimilarity(); + void configure(const float binarizePercentile=0.095, const int frameStackSize=9, const int frameStackStride=1, const int noti=12, const bool oti=true, const bool otiBinary=false, const bool streaming=false); + val compute(std::vector >& input_queryFeature, std::vector >& input_referenceFeature); + void reset(); + private: + Algorithm* _chromacrosssimilarity; +}; + +class Chromagram { + public: + Chromagram(const int binsPerOctave=12, const float minFrequency=32.7, const int minimumKernelSize=4, const std::string& normalizeType="unit_max", const int numberBins=84, const float sampleRate=44100, const float scale=1, const float threshold=0.01, const std::string& windowType="hann", const bool zeroPhase=true); + ~Chromagram(); + void configure(const int binsPerOctave=12, const float minFrequency=32.7, const int minimumKernelSize=4, const std::string& normalizeType="unit_max", const int numberBins=84, const float sampleRate=44100, const float scale=1, const float threshold=0.01, const std::string& windowType="hann", const bool zeroPhase=true); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _chromagram; +}; + +class ClickDetector { + public: + ClickDetector(const float detectionThreshold=30, const int frameSize=512, const int hopSize=256, const int order=12, const int powerEstimationThreshold=10, const float sampleRate=44100, const int silenceThreshold=-50); + ~ClickDetector(); + void configure(const float detectionThreshold=30, const int frameSize=512, const int hopSize=256, const int order=12, const int powerEstimationThreshold=10, const float sampleRate=44100, const int silenceThreshold=-50); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _clickdetector; +}; + +class Clipper { + public: + Clipper(const float max=1, const float min=-1); + ~Clipper(); + void configure(const float max=1, const float min=-1); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _clipper; +}; + +class CoverSongSimilarity { + public: + CoverSongSimilarity(const std::string& alignmentType="serra09", const float disExtension=0.5, const float disOnset=0.5, const std::string& distanceType="asymmetric"); + ~CoverSongSimilarity(); + void configure(const std::string& alignmentType="serra09", const float disExtension=0.5, const float disOnset=0.5, const std::string& distanceType="asymmetric"); + val compute(std::vector >& input_inputArray); + void reset(); + private: + Algorithm* _coversongsimilarity; +}; + +class Crest { + public: + Crest(); + ~Crest(); + void configure(); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _crest; +}; + +class CrossCorrelation { + public: + CrossCorrelation(const int maxLag=1, const int minLag=0); + ~CrossCorrelation(); + void configure(const int maxLag=1, const int minLag=0); + val compute(std::vector& input_arrayX, std::vector& input_arrayY); + void reset(); + private: + Algorithm* _crosscorrelation; +}; + +class CrossSimilarityMatrix { + public: + CrossSimilarityMatrix(const bool binarize=false, const float binarizePercentile=0.095, const int frameStackSize=1, const int frameStackStride=1); + ~CrossSimilarityMatrix(); + void configure(const bool binarize=false, const float binarizePercentile=0.095, const int frameStackSize=1, const int frameStackStride=1); + val compute(std::vector >& input_queryFeature, std::vector >& input_referenceFeature); + void reset(); + private: + Algorithm* _crosssimilaritymatrix; +}; + +class CubicSpline { + public: + CubicSpline(const int leftBoundaryFlag=0, const float leftBoundaryValue=0, const int rightBoundaryFlag=0, const float rightBoundaryValue=0, const std::vector& xPoints=std::vector{0, 1}, const std::vector& yPoints=std::vector{0, 1}); + ~CubicSpline(); + void configure(const int leftBoundaryFlag=0, const float leftBoundaryValue=0, const int rightBoundaryFlag=0, const float rightBoundaryValue=0, const std::vector& xPoints=std::vector{0, 1}, const std::vector& yPoints=std::vector{0, 1}); + val compute(float input_x); + void reset(); + private: + Algorithm* _cubicspline; +}; + +class DCRemoval { + public: + DCRemoval(const float cutoffFrequency=40, const float sampleRate=44100); + ~DCRemoval(); + void configure(const float cutoffFrequency=40, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _dcremoval; +}; + +class DCT { + public: + DCT(const int dctType=2, const int inputSize=10, const int liftering=0, const int outputSize=10); + ~DCT(); + void configure(const int dctType=2, const int inputSize=10, const int liftering=0, const int outputSize=10); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _dct; +}; + +class Danceability { + public: + Danceability(const float maxTau=8800, const float minTau=310, const float sampleRate=44100, const float tauMultiplier=1.1); + ~Danceability(); + void configure(const float maxTau=8800, const float minTau=310, const float sampleRate=44100, const float tauMultiplier=1.1); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _danceability; +}; + +class Decrease { + public: + Decrease(const float range=1); + ~Decrease(); + void configure(const float range=1); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _decrease; +}; + +class Derivative { + public: + Derivative(); + ~Derivative(); + void configure(); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _derivative; +}; + +class DerivativeSFX { + public: + DerivativeSFX(); + ~DerivativeSFX(); + void configure(); + val compute(std::vector& input_envelope); + void reset(); + private: + Algorithm* _derivativesfx; +}; + +class DiscontinuityDetector { + public: + DiscontinuityDetector(const float detectionThreshold=8, const float energyThreshold=-60, const int frameSize=512, const int hopSize=256, const int kernelSize=7, const int order=3, const int silenceThreshold=-50, const int subFrameSize=32); + ~DiscontinuityDetector(); + void configure(const float detectionThreshold=8, const float energyThreshold=-60, const int frameSize=512, const int hopSize=256, const int kernelSize=7, const int order=3, const int silenceThreshold=-50, const int subFrameSize=32); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _discontinuitydetector; +}; + +class Dissonance { + public: + Dissonance(); + ~Dissonance(); + void configure(); + val compute(std::vector& input_frequencies, std::vector& input_magnitudes); + void reset(); + private: + Algorithm* _dissonance; +}; + +class DistributionShape { + public: + DistributionShape(); + ~DistributionShape(); + void configure(); + val compute(std::vector& input_centralMoments); + void reset(); + private: + Algorithm* _distributionshape; +}; + +class Duration { + public: + Duration(const float sampleRate=44100); + ~Duration(); + void configure(const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _duration; +}; + +class DynamicComplexity { + public: + DynamicComplexity(const float frameSize=0.2, const float sampleRate=44100); + ~DynamicComplexity(); + void configure(const float frameSize=0.2, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _dynamiccomplexity; +}; + +class ERBBands { + public: + ERBBands(const float highFrequencyBound=22050, const int inputSize=1025, const float lowFrequencyBound=50, const int numberBands=40, const float sampleRate=44100, const std::string& type="power", const float width=1); + ~ERBBands(); + void configure(const float highFrequencyBound=22050, const int inputSize=1025, const float lowFrequencyBound=50, const int numberBands=40, const float sampleRate=44100, const std::string& type="power", const float width=1); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _erbbands; +}; + +class EffectiveDuration { + public: + EffectiveDuration(const float sampleRate=44100, const float thresholdRatio=0.4); + ~EffectiveDuration(); + void configure(const float sampleRate=44100, const float thresholdRatio=0.4); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _effectiveduration; +}; + +class Energy { + public: + Energy(); + ~Energy(); + void configure(); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _energy; +}; + +class EnergyBand { + public: + EnergyBand(const float sampleRate=44100, const float startCutoffFrequency=0, const float stopCutoffFrequency=100); + ~EnergyBand(); + void configure(const float sampleRate=44100, const float startCutoffFrequency=0, const float stopCutoffFrequency=100); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _energyband; +}; + +class EnergyBandRatio { + public: + EnergyBandRatio(const float sampleRate=44100, const float startFrequency=0, const float stopFrequency=100); + ~EnergyBandRatio(); + void configure(const float sampleRate=44100, const float startFrequency=0, const float stopFrequency=100); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _energybandratio; +}; + +class Entropy { + public: + Entropy(); + ~Entropy(); + void configure(); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _entropy; +}; + +class Envelope { + public: + Envelope(const bool applyRectification=true, const float attackTime=10, const float releaseTime=1500, const float sampleRate=44100); + ~Envelope(); + void configure(const bool applyRectification=true, const float attackTime=10, const float releaseTime=1500, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _envelope; +}; + +class EqualLoudness { + public: + EqualLoudness(const float sampleRate=44100); + ~EqualLoudness(); + void configure(const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _equalloudness; +}; + +class Flatness { + public: + Flatness(); + ~Flatness(); + void configure(); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _flatness; +}; + +class FlatnessDB { + public: + FlatnessDB(); + ~FlatnessDB(); + void configure(); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _flatnessdb; +}; + +class FlatnessSFX { + public: + FlatnessSFX(); + ~FlatnessSFX(); + void configure(); + val compute(std::vector& input_envelope); + void reset(); + private: + Algorithm* _flatnesssfx; +}; + +class Flux { + public: + Flux(const bool halfRectify=false, const std::string& norm="L2"); + ~Flux(); + void configure(const bool halfRectify=false, const std::string& norm="L2"); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _flux; +}; + +class FrameCutter { + public: + FrameCutter(const int frameSize=1024, const int hopSize=512, const bool lastFrameToEndOfFile=false, const bool startFromZero=false, const float validFrameThresholdRatio=0); + ~FrameCutter(); + void configure(const int frameSize=1024, const int hopSize=512, const bool lastFrameToEndOfFile=false, const bool startFromZero=false, const float validFrameThresholdRatio=0); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _framecutter; +}; + +class FrameToReal { + public: + FrameToReal(const int frameSize=2048, const int hopSize=128); + ~FrameToReal(); + void configure(const int frameSize=2048, const int hopSize=128); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _frametoreal; +}; + +class FrequencyBands { + public: + FrequencyBands(const std::vector& frequencyBands=std::vector{0, 50, 100, 150, 200, 300, 400, 510, 630, 770, 920, 1080, 1270, 1480, 1720, 2000, 2320, 2700, 3150, 3700, 4400, 5300, 6400, 7700, 9500, 12000, 15500, 20500, 27000}, const float sampleRate=44100); + ~FrequencyBands(); + void configure(const std::vector& frequencyBands=std::vector{0, 50, 100, 150, 200, 300, 400, 510, 630, 770, 920, 1080, 1270, 1480, 1720, 2000, 2320, 2700, 3150, 3700, 4400, 5300, 6400, 7700, 9500, 12000, 15500, 20500, 27000}, const float sampleRate=44100); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _frequencybands; +}; + +class GFCC { + public: + GFCC(const int dctType=2, const float highFrequencyBound=22050, const int inputSize=1025, const std::string& logType="dbamp", const float lowFrequencyBound=40, const int numberBands=40, const int numberCoefficients=13, const float sampleRate=44100, const float silenceThreshold=1e-10, const std::string& type="power"); + ~GFCC(); + void configure(const int dctType=2, const float highFrequencyBound=22050, const int inputSize=1025, const std::string& logType="dbamp", const float lowFrequencyBound=40, const int numberBands=40, const int numberCoefficients=13, const float sampleRate=44100, const float silenceThreshold=1e-10, const std::string& type="power"); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _gfcc; +}; + +class GapsDetector { + public: + GapsDetector(const float attackTime=0.05, const int frameSize=2048, const int hopSize=1024, const int kernelSize=11, const float maximumTime=3500, const float minimumTime=10, const float postpowerTime=40, const float prepowerThreshold=-30, const float prepowerTime=40, const float releaseTime=0.05, const float sampleRate=44100, const float silenceThreshold=-50); + ~GapsDetector(); + void configure(const float attackTime=0.05, const int frameSize=2048, const int hopSize=1024, const int kernelSize=11, const float maximumTime=3500, const float minimumTime=10, const float postpowerTime=40, const float prepowerThreshold=-30, const float prepowerTime=40, const float releaseTime=0.05, const float sampleRate=44100, const float silenceThreshold=-50); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _gapsdetector; +}; + +class GeometricMean { + public: + GeometricMean(); + ~GeometricMean(); + void configure(); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _geometricmean; +}; + +class HFC { + public: + HFC(const float sampleRate=44100, const std::string& type="Masri"); + ~HFC(); + void configure(const float sampleRate=44100, const std::string& type="Masri"); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _hfc; +}; + +class HPCP { + public: + HPCP(const bool bandPreset=true, const float bandSplitFrequency=500, const int harmonics=0, const float maxFrequency=5000, const bool maxShifted=false, const float minFrequency=40, const bool nonLinear=false, const std::string& normalized="unitMax", const float referenceFrequency=440, const float sampleRate=44100, const int size=12, const std::string& weightType="squaredCosine", const float windowSize=1); + ~HPCP(); + void configure(const bool bandPreset=true, const float bandSplitFrequency=500, const int harmonics=0, const float maxFrequency=5000, const bool maxShifted=false, const float minFrequency=40, const bool nonLinear=false, const std::string& normalized="unitMax", const float referenceFrequency=440, const float sampleRate=44100, const int size=12, const std::string& weightType="squaredCosine", const float windowSize=1); + val compute(std::vector& input_frequencies, std::vector& input_magnitudes); + void reset(); + private: + Algorithm* _hpcp; +}; + +class HarmonicBpm { + public: + HarmonicBpm(const float bpm=60, const float threshold=20, const float tolerance=5); + ~HarmonicBpm(); + void configure(const float bpm=60, const float threshold=20, const float tolerance=5); + val compute(std::vector& input_bpms); + void reset(); + private: + Algorithm* _harmonicbpm; +}; + +class HarmonicPeaks { + public: + HarmonicPeaks(const int maxHarmonics=20, const float tolerance=0.2); + ~HarmonicPeaks(); + void configure(const int maxHarmonics=20, const float tolerance=0.2); + val compute(std::vector& input_frequencies, std::vector& input_magnitudes, float input_pitch); + void reset(); + private: + Algorithm* _harmonicpeaks; +}; + +class HighPass { + public: + HighPass(const float cutoffFrequency=1500, const float sampleRate=44100); + ~HighPass(); + void configure(const float cutoffFrequency=1500, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _highpass; +}; + +class HighResolutionFeatures { + public: + HighResolutionFeatures(const int maxPeaks=24); + ~HighResolutionFeatures(); + void configure(const int maxPeaks=24); + val compute(std::vector& input_hpcp); + void reset(); + private: + Algorithm* _highresolutionfeatures; +}; + +class Histogram { + public: + Histogram(const float maxValue=1, const float minValue=0, const std::string& normalize="none", const int numberBins=10); + ~Histogram(); + void configure(const float maxValue=1, const float minValue=0, const std::string& normalize="none", const int numberBins=10); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _histogram; +}; + +class HprModelAnal { + public: + HprModelAnal(const int fftSize=2048, const int freqDevOffset=20, const float freqDevSlope=0.01, const float harmDevSlope=0.01, const int hopSize=512, const float magnitudeThreshold=0, const float maxFrequency=5000, const int maxPeaks=100, const int maxnSines=100, const float minFrequency=20, const int nHarmonics=100, const std::string& orderBy="frequency", const float sampleRate=44100, const float stocf=0.2); + ~HprModelAnal(); + void configure(const int fftSize=2048, const int freqDevOffset=20, const float freqDevSlope=0.01, const float harmDevSlope=0.01, const int hopSize=512, const float magnitudeThreshold=0, const float maxFrequency=5000, const int maxPeaks=100, const int maxnSines=100, const float minFrequency=20, const int nHarmonics=100, const std::string& orderBy="frequency", const float sampleRate=44100, const float stocf=0.2); + val compute(std::vector& input_frame, float input_pitch); + void reset(); + private: + Algorithm* _hprmodelanal; +}; + +class HpsModelAnal { + public: + HpsModelAnal(const int fftSize=2048, const int freqDevOffset=20, const float freqDevSlope=0.01, const float harmDevSlope=0.01, const int hopSize=512, const float magnitudeThreshold=0, const float maxFrequency=5000, const int maxPeaks=100, const int maxnSines=100, const float minFrequency=20, const int nHarmonics=100, const std::string& orderBy="frequency", const float sampleRate=44100, const float stocf=0.2); + ~HpsModelAnal(); + void configure(const int fftSize=2048, const int freqDevOffset=20, const float freqDevSlope=0.01, const float harmDevSlope=0.01, const int hopSize=512, const float magnitudeThreshold=0, const float maxFrequency=5000, const int maxPeaks=100, const int maxnSines=100, const float minFrequency=20, const int nHarmonics=100, const std::string& orderBy="frequency", const float sampleRate=44100, const float stocf=0.2); + val compute(std::vector& input_frame, float input_pitch); + void reset(); + private: + Algorithm* _hpsmodelanal; +}; + +class IDCT { + public: + IDCT(const int dctType=2, const int inputSize=10, const int liftering=0, const int outputSize=10); + ~IDCT(); + void configure(const int dctType=2, const int inputSize=10, const int liftering=0, const int outputSize=10); + val compute(std::vector& input_dct); + void reset(); + private: + Algorithm* _idct; +}; + +class IIR { + public: + IIR(const std::vector& denominator=std::vector{1}, const std::vector& numerator=std::vector{1}); + ~IIR(); + void configure(const std::vector& denominator=std::vector{1}, const std::vector& numerator=std::vector{1}); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _iir; +}; + +class Inharmonicity { + public: + Inharmonicity(); + ~Inharmonicity(); + void configure(); + val compute(std::vector& input_frequencies, std::vector& input_magnitudes); + void reset(); + private: + Algorithm* _inharmonicity; +}; + +class InstantPower { + public: + InstantPower(); + ~InstantPower(); + void configure(); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _instantpower; +}; + +class Intensity { + public: + Intensity(const float sampleRate=44100); + ~Intensity(); + void configure(const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _intensity; +}; + +class Key { + public: + Key(const int numHarmonics=4, const int pcpSize=36, const std::string& profileType="bgate", const float slope=0.6, const bool useMajMin=false, const bool usePolyphony=true, const bool useThreeChords=true); + ~Key(); + void configure(const int numHarmonics=4, const int pcpSize=36, const std::string& profileType="bgate", const float slope=0.6, const bool useMajMin=false, const bool usePolyphony=true, const bool useThreeChords=true); + val compute(std::vector& input_pcp); + void reset(); + private: + Algorithm* _key; +}; + +class KeyExtractor { + public: + KeyExtractor(const bool averageDetuningCorrection=true, const int frameSize=4096, const int hopSize=4096, const int hpcpSize=12, const float maxFrequency=3500, const int maximumSpectralPeaks=60, const float minFrequency=25, const float pcpThreshold=0.2, const std::string& profileType="bgate", const float sampleRate=44100, const float spectralPeaksThreshold=0.0001, const float tuningFrequency=440, const std::string& weightType="cosine", const std::string& windowType="hann"); + ~KeyExtractor(); + void configure(const bool averageDetuningCorrection=true, const int frameSize=4096, const int hopSize=4096, const int hpcpSize=12, const float maxFrequency=3500, const int maximumSpectralPeaks=60, const float minFrequency=25, const float pcpThreshold=0.2, const std::string& profileType="bgate", const float sampleRate=44100, const float spectralPeaksThreshold=0.0001, const float tuningFrequency=440, const std::string& weightType="cosine", const std::string& windowType="hann"); + val compute(std::vector& input_audio); + void reset(); + private: + Algorithm* _keyextractor; +}; + +class LPC { + public: + LPC(const int order=10, const float sampleRate=44100, const std::string& type="regular"); + ~LPC(); + void configure(const int order=10, const float sampleRate=44100, const std::string& type="regular"); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _lpc; +}; + +class Larm { + public: + Larm(const float attackTime=10, const float power=1.5, const float releaseTime=1500, const float sampleRate=44100); + ~Larm(); + void configure(const float attackTime=10, const float power=1.5, const float releaseTime=1500, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _larm; +}; + +class Leq { + public: + Leq(); + ~Leq(); + void configure(); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _leq; +}; + +class LevelExtractor { + public: + LevelExtractor(const int frameSize=88200, const int hopSize=44100); + ~LevelExtractor(); + void configure(const int frameSize=88200, const int hopSize=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _levelextractor; +}; + +class LogAttackTime { + public: + LogAttackTime(const float sampleRate=44100, const float startAttackThreshold=0.2, const float stopAttackThreshold=0.9); + ~LogAttackTime(); + void configure(const float sampleRate=44100, const float startAttackThreshold=0.2, const float stopAttackThreshold=0.9); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _logattacktime; +}; + +class LogSpectrum { + public: + LogSpectrum(const float binsPerSemitone=3, const int frameSize=1025, const int nOctave=7, const float rollOn=0, const float sampleRate=44100); + ~LogSpectrum(); + void configure(const float binsPerSemitone=3, const int frameSize=1025, const int nOctave=7, const float rollOn=0, const float sampleRate=44100); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _logspectrum; +}; + +class LoopBpmConfidence { + public: + LoopBpmConfidence(const float sampleRate=44100); + ~LoopBpmConfidence(); + void configure(const float sampleRate=44100); + val compute(std::vector& input_signal, float input_bpmEstimate); + void reset(); + private: + Algorithm* _loopbpmconfidence; +}; + +class LoopBpmEstimator { + public: + LoopBpmEstimator(const float confidenceThreshold=0.95); + ~LoopBpmEstimator(); + void configure(const float confidenceThreshold=0.95); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _loopbpmestimator; +}; + +class Loudness { + public: + Loudness(); + ~Loudness(); + void configure(); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _loudness; +}; + +class LoudnessVickers { + public: + LoudnessVickers(const float sampleRate=44100); + ~LoudnessVickers(); + void configure(const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _loudnessvickers; +}; + +class LowLevelSpectralEqloudExtractor { + public: + LowLevelSpectralEqloudExtractor(const int frameSize=2048, const int hopSize=1024, const float sampleRate=44100); + ~LowLevelSpectralEqloudExtractor(); + void configure(const int frameSize=2048, const int hopSize=1024, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _lowlevelspectraleqloudextractor; +}; + +class LowLevelSpectralExtractor { + public: + LowLevelSpectralExtractor(const int frameSize=2048, const int hopSize=1024, const float sampleRate=44100); + ~LowLevelSpectralExtractor(); + void configure(const int frameSize=2048, const int hopSize=1024, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _lowlevelspectralextractor; +}; + +class LowPass { + public: + LowPass(const float cutoffFrequency=1500, const float sampleRate=44100); + ~LowPass(); + void configure(const float cutoffFrequency=1500, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _lowpass; +}; + +class MFCC { + public: + MFCC(const int dctType=2, const float highFrequencyBound=11000, const int inputSize=1025, const int liftering=0, const std::string& logType="dbamp", const float lowFrequencyBound=0, const std::string& normalize="unit_sum", const int numberBands=40, const int numberCoefficients=13, const float sampleRate=44100, const float silenceThreshold=1e-10, const std::string& type="power", const std::string& warpingFormula="htkMel", const std::string& weighting="warping"); + ~MFCC(); + void configure(const int dctType=2, const float highFrequencyBound=11000, const int inputSize=1025, const int liftering=0, const std::string& logType="dbamp", const float lowFrequencyBound=0, const std::string& normalize="unit_sum", const int numberBands=40, const int numberCoefficients=13, const float sampleRate=44100, const float silenceThreshold=1e-10, const std::string& type="power", const std::string& warpingFormula="htkMel", const std::string& weighting="warping"); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _mfcc; +}; + +class MaxFilter { + public: + MaxFilter(const bool causal=true, const int width=3); + ~MaxFilter(); + void configure(const bool causal=true, const int width=3); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _maxfilter; +}; + +class MaxMagFreq { + public: + MaxMagFreq(const float sampleRate=44100); + ~MaxMagFreq(); + void configure(const float sampleRate=44100); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _maxmagfreq; +}; + +class MaxToTotal { + public: + MaxToTotal(); + ~MaxToTotal(); + void configure(); + val compute(std::vector& input_envelope); + void reset(); + private: + Algorithm* _maxtototal; +}; + +class Mean { + public: + Mean(); + ~Mean(); + void configure(); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _mean; +}; + +class Median { + public: + Median(); + ~Median(); + void configure(); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _median; +}; + +class MedianFilter { + public: + MedianFilter(const int kernelSize=11); + ~MedianFilter(); + void configure(const int kernelSize=11); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _medianfilter; +}; + +class MelBands { + public: + MelBands(const float highFrequencyBound=22050, const int inputSize=1025, const bool log=false, const float lowFrequencyBound=0, const std::string& normalize="unit_sum", const int numberBands=24, const float sampleRate=44100, const std::string& type="power", const std::string& warpingFormula="htkMel", const std::string& weighting="warping"); + ~MelBands(); + void configure(const float highFrequencyBound=22050, const int inputSize=1025, const bool log=false, const float lowFrequencyBound=0, const std::string& normalize="unit_sum", const int numberBands=24, const float sampleRate=44100, const std::string& type="power", const std::string& warpingFormula="htkMel", const std::string& weighting="warping"); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _melbands; +}; + +class Meter { + public: + Meter(); + ~Meter(); + void configure(); + val compute(std::vector >& input_beatogram); + void reset(); + private: + Algorithm* _meter; +}; + +class MinMax { + public: + MinMax(const std::string& type="min"); + ~MinMax(); + void configure(const std::string& type="min"); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _minmax; +}; + +class MinToTotal { + public: + MinToTotal(); + ~MinToTotal(); + void configure(); + val compute(std::vector& input_envelope); + void reset(); + private: + Algorithm* _mintototal; +}; + +class MovingAverage { + public: + MovingAverage(const int size=6); + ~MovingAverage(); + void configure(const int size=6); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _movingaverage; +}; + +class MultiPitchKlapuri { + public: + MultiPitchKlapuri(const float binResolution=10, const int frameSize=2048, const float harmonicWeight=0.8, const int hopSize=128, const float magnitudeCompression=1, const int magnitudeThreshold=40, const float maxFrequency=1760, const float minFrequency=80, const int numberHarmonics=10, const float referenceFrequency=55, const float sampleRate=44100); + ~MultiPitchKlapuri(); + void configure(const float binResolution=10, const int frameSize=2048, const float harmonicWeight=0.8, const int hopSize=128, const float magnitudeCompression=1, const int magnitudeThreshold=40, const float maxFrequency=1760, const float minFrequency=80, const int numberHarmonics=10, const float referenceFrequency=55, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _multipitchklapuri; +}; + +class MultiPitchMelodia { + public: + MultiPitchMelodia(const float binResolution=10, const int filterIterations=3, const int frameSize=2048, const bool guessUnvoiced=false, const float harmonicWeight=0.8, const int hopSize=128, const float magnitudeCompression=1, const int magnitudeThreshold=40, const float maxFrequency=20000, const int minDuration=100, const float minFrequency=40, const int numberHarmonics=20, const float peakDistributionThreshold=0.9, const float peakFrameThreshold=0.9, const float pitchContinuity=27.5625, const float referenceFrequency=55, const float sampleRate=44100, const int timeContinuity=100); + ~MultiPitchMelodia(); + void configure(const float binResolution=10, const int filterIterations=3, const int frameSize=2048, const bool guessUnvoiced=false, const float harmonicWeight=0.8, const int hopSize=128, const float magnitudeCompression=1, const int magnitudeThreshold=40, const float maxFrequency=20000, const int minDuration=100, const float minFrequency=40, const int numberHarmonics=20, const float peakDistributionThreshold=0.9, const float peakFrameThreshold=0.9, const float pitchContinuity=27.5625, const float referenceFrequency=55, const float sampleRate=44100, const int timeContinuity=100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _multipitchmelodia; +}; + +class Multiplexer { + public: + Multiplexer(const int numberRealInputs=0, const int numberVectorRealInputs=0); + ~Multiplexer(); + void configure(const int numberRealInputs=0, const int numberVectorRealInputs=0); + val compute(); + void reset(); + private: + Algorithm* _multiplexer; +}; + +class NNLSChroma { + public: + NNLSChroma(const std::string& chromaNormalization="none", const int frameSize=1025, const float sampleRate=44100, const float spectralShape=0.7, const float spectralWhitening=1, const std::string& tuningMode="global", const bool useNNLS=true); + ~NNLSChroma(); + void configure(const std::string& chromaNormalization="none", const int frameSize=1025, const float sampleRate=44100, const float spectralShape=0.7, const float spectralWhitening=1, const std::string& tuningMode="global", const bool useNNLS=true); + val compute(std::vector >& input_logSpectrogram, std::vector& input_meanTuning, std::vector& input_localTuning); + void reset(); + private: + Algorithm* _nnlschroma; +}; + +class NoiseAdder { + public: + NoiseAdder(const bool fixSeed=false, const int level=-100); + ~NoiseAdder(); + void configure(const bool fixSeed=false, const int level=-100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _noiseadder; +}; + +class NoiseBurstDetector { + public: + NoiseBurstDetector(const float alpha=0.9, const int silenceThreshold=-50, const int threshold=8); + ~NoiseBurstDetector(); + void configure(const float alpha=0.9, const int silenceThreshold=-50, const int threshold=8); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _noiseburstdetector; +}; + +class NoveltyCurve { + public: + NoveltyCurve(const float frameRate=344.531, const bool normalize=false, const std::vector& weightCurve=std::vector(), const std::string& weightCurveType="hybrid"); + ~NoveltyCurve(); + void configure(const float frameRate=344.531, const bool normalize=false, const std::vector& weightCurve=std::vector(), const std::string& weightCurveType="hybrid"); + val compute(std::vector >& input_frequencyBands); + void reset(); + private: + Algorithm* _noveltycurve; +}; + +class NoveltyCurveFixedBpmEstimator { + public: + NoveltyCurveFixedBpmEstimator(const int hopSize=512, const float maxBpm=560, const float minBpm=30, const float sampleRate=44100, const float tolerance=3); + ~NoveltyCurveFixedBpmEstimator(); + void configure(const int hopSize=512, const float maxBpm=560, const float minBpm=30, const float sampleRate=44100, const float tolerance=3); + val compute(std::vector& input_novelty); + void reset(); + private: + Algorithm* _noveltycurvefixedbpmestimator; +}; + +class OddToEvenHarmonicEnergyRatio { + public: + OddToEvenHarmonicEnergyRatio(); + ~OddToEvenHarmonicEnergyRatio(); + void configure(); + val compute(std::vector& input_frequencies, std::vector& input_magnitudes); + void reset(); + private: + Algorithm* _oddtoevenharmonicenergyratio; +}; + +class OnsetDetection { + public: + OnsetDetection(const std::string& method="hfc", const float sampleRate=44100); + ~OnsetDetection(); + void configure(const std::string& method="hfc", const float sampleRate=44100); + val compute(std::vector& input_spectrum, std::vector& input_phase); + void reset(); + private: + Algorithm* _onsetdetection; +}; + +class OnsetDetectionGlobal { + public: + OnsetDetectionGlobal(const int frameSize=2048, const int hopSize=512, const std::string& method="infogain", const float sampleRate=44100); + ~OnsetDetectionGlobal(); + void configure(const int frameSize=2048, const int hopSize=512, const std::string& method="infogain", const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _onsetdetectionglobal; +}; + +class OnsetRate { + public: + OnsetRate(); + ~OnsetRate(); + void configure(); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _onsetrate; +}; + +class OverlapAdd { + public: + OverlapAdd(const int frameSize=2048, const float gain=1, const int hopSize=128); + ~OverlapAdd(); + void configure(const int frameSize=2048, const float gain=1, const int hopSize=128); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _overlapadd; +}; + +class PeakDetection { + public: + PeakDetection(const bool interpolate=true, const int maxPeaks=100, const float maxPosition=1, const float minPeakDistance=0, const float minPosition=0, const std::string& orderBy="position", const float range=1, const float threshold=-1e+06); + ~PeakDetection(); + void configure(const bool interpolate=true, const int maxPeaks=100, const float maxPosition=1, const float minPeakDistance=0, const float minPosition=0, const std::string& orderBy="position", const float range=1, const float threshold=-1e+06); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _peakdetection; +}; + +class PercivalBpmEstimator { + public: + PercivalBpmEstimator(const int frameSize=1024, const int frameSizeOSS=2048, const int hopSize=128, const int hopSizeOSS=128, const int maxBPM=210, const int minBPM=50, const int sampleRate=44100); + ~PercivalBpmEstimator(); + void configure(const int frameSize=1024, const int frameSizeOSS=2048, const int hopSize=128, const int hopSizeOSS=128, const int maxBPM=210, const int minBPM=50, const int sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _percivalbpmestimator; +}; + +class PercivalEnhanceHarmonics { + public: + PercivalEnhanceHarmonics(); + ~PercivalEnhanceHarmonics(); + void configure(); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _percivalenhanceharmonics; +}; + +class PercivalEvaluatePulseTrains { + public: + PercivalEvaluatePulseTrains(); + ~PercivalEvaluatePulseTrains(); + void configure(); + val compute(std::vector& input_oss, std::vector& input_positions); + void reset(); + private: + Algorithm* _percivalevaluatepulsetrains; +}; + +class PitchContourSegmentation { + public: + PitchContourSegmentation(const int hopSize=128, const float minDuration=0.1, const int pitchDistanceThreshold=60, const int rmsThreshold=-2, const int sampleRate=44100, const int tuningFrequency=440); + ~PitchContourSegmentation(); + void configure(const int hopSize=128, const float minDuration=0.1, const int pitchDistanceThreshold=60, const int rmsThreshold=-2, const int sampleRate=44100, const int tuningFrequency=440); + val compute(std::vector& input_pitch, std::vector& input_signal); + void reset(); + private: + Algorithm* _pitchcontoursegmentation; +}; + +class PitchContours { + public: + PitchContours(const float binResolution=10, const int hopSize=128, const float minDuration=100, const float peakDistributionThreshold=0.9, const float peakFrameThreshold=0.9, const float pitchContinuity=27.5625, const float sampleRate=44100, const float timeContinuity=100); + ~PitchContours(); + void configure(const float binResolution=10, const int hopSize=128, const float minDuration=100, const float peakDistributionThreshold=0.9, const float peakFrameThreshold=0.9, const float pitchContinuity=27.5625, const float sampleRate=44100, const float timeContinuity=100); + val compute(std::vector >& input_peakBins, std::vector >& input_peakSaliences); + void reset(); + private: + Algorithm* _pitchcontours; +}; + +class PitchContoursMelody { + public: + PitchContoursMelody(const float binResolution=10, const int filterIterations=3, const bool guessUnvoiced=false, const int hopSize=128, const float maxFrequency=20000, const float minFrequency=80, const float referenceFrequency=55, const float sampleRate=44100, const bool voiceVibrato=false, const float voicingTolerance=0.2); + ~PitchContoursMelody(); + void configure(const float binResolution=10, const int filterIterations=3, const bool guessUnvoiced=false, const int hopSize=128, const float maxFrequency=20000, const float minFrequency=80, const float referenceFrequency=55, const float sampleRate=44100, const bool voiceVibrato=false, const float voicingTolerance=0.2); + val compute(std::vector >& input_contoursBins, std::vector >& input_contoursSaliences, std::vector& input_contoursStartTimes, float input_duration); + void reset(); + private: + Algorithm* _pitchcontoursmelody; +}; + +class PitchContoursMonoMelody { + public: + PitchContoursMonoMelody(const float binResolution=10, const int filterIterations=3, const bool guessUnvoiced=false, const int hopSize=128, const float maxFrequency=20000, const float minFrequency=80, const float referenceFrequency=55, const float sampleRate=44100); + ~PitchContoursMonoMelody(); + void configure(const float binResolution=10, const int filterIterations=3, const bool guessUnvoiced=false, const int hopSize=128, const float maxFrequency=20000, const float minFrequency=80, const float referenceFrequency=55, const float sampleRate=44100); + val compute(std::vector >& input_contoursBins, std::vector >& input_contoursSaliences, std::vector& input_contoursStartTimes, float input_duration); + void reset(); + private: + Algorithm* _pitchcontoursmonomelody; +}; + +class PitchContoursMultiMelody { + public: + PitchContoursMultiMelody(const float binResolution=10, const int filterIterations=3, const bool guessUnvoiced=false, const int hopSize=128, const float maxFrequency=20000, const float minFrequency=80, const float referenceFrequency=55, const float sampleRate=44100); + ~PitchContoursMultiMelody(); + void configure(const float binResolution=10, const int filterIterations=3, const bool guessUnvoiced=false, const int hopSize=128, const float maxFrequency=20000, const float minFrequency=80, const float referenceFrequency=55, const float sampleRate=44100); + val compute(std::vector >& input_contoursBins, std::vector >& input_contoursSaliences, std::vector& input_contoursStartTimes, float input_duration); + void reset(); + private: + Algorithm* _pitchcontoursmultimelody; +}; + +class PitchFilter { + public: + PitchFilter(const int confidenceThreshold=36, const int minChunkSize=30, const bool useAbsolutePitchConfidence=false); + ~PitchFilter(); + void configure(const int confidenceThreshold=36, const int minChunkSize=30, const bool useAbsolutePitchConfidence=false); + val compute(std::vector& input_pitch, std::vector& input_pitchConfidence); + void reset(); + private: + Algorithm* _pitchfilter; +}; + +class PitchMelodia { + public: + PitchMelodia(const float binResolution=10, const int filterIterations=3, const int frameSize=2048, const bool guessUnvoiced=false, const float harmonicWeight=0.8, const int hopSize=128, const float magnitudeCompression=1, const int magnitudeThreshold=40, const float maxFrequency=20000, const int minDuration=100, const float minFrequency=40, const int numberHarmonics=20, const float peakDistributionThreshold=0.9, const float peakFrameThreshold=0.9, const float pitchContinuity=27.5625, const float referenceFrequency=55, const float sampleRate=44100, const int timeContinuity=100); + ~PitchMelodia(); + void configure(const float binResolution=10, const int filterIterations=3, const int frameSize=2048, const bool guessUnvoiced=false, const float harmonicWeight=0.8, const int hopSize=128, const float magnitudeCompression=1, const int magnitudeThreshold=40, const float maxFrequency=20000, const int minDuration=100, const float minFrequency=40, const int numberHarmonics=20, const float peakDistributionThreshold=0.9, const float peakFrameThreshold=0.9, const float pitchContinuity=27.5625, const float referenceFrequency=55, const float sampleRate=44100, const int timeContinuity=100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _pitchmelodia; +}; + +class PitchSalience { + public: + PitchSalience(const float highBoundary=5000, const float lowBoundary=100, const float sampleRate=44100); + ~PitchSalience(); + void configure(const float highBoundary=5000, const float lowBoundary=100, const float sampleRate=44100); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _pitchsalience; +}; + +class PitchSalienceFunction { + public: + PitchSalienceFunction(const float binResolution=10, const float harmonicWeight=0.8, const float magnitudeCompression=1, const float magnitudeThreshold=40, const int numberHarmonics=20, const float referenceFrequency=55); + ~PitchSalienceFunction(); + void configure(const float binResolution=10, const float harmonicWeight=0.8, const float magnitudeCompression=1, const float magnitudeThreshold=40, const int numberHarmonics=20, const float referenceFrequency=55); + val compute(std::vector& input_frequencies, std::vector& input_magnitudes); + void reset(); + private: + Algorithm* _pitchsaliencefunction; +}; + +class PitchSalienceFunctionPeaks { + public: + PitchSalienceFunctionPeaks(const float binResolution=10, const float maxFrequency=1760, const float minFrequency=55, const float referenceFrequency=55); + ~PitchSalienceFunctionPeaks(); + void configure(const float binResolution=10, const float maxFrequency=1760, const float minFrequency=55, const float referenceFrequency=55); + val compute(std::vector& input_salienceFunction); + void reset(); + private: + Algorithm* _pitchsaliencefunctionpeaks; +}; + +class PitchYin { + public: + PitchYin(const int frameSize=2048, const bool interpolate=true, const float maxFrequency=22050, const float minFrequency=20, const float sampleRate=44100, const float tolerance=0.15); + ~PitchYin(); + void configure(const int frameSize=2048, const bool interpolate=true, const float maxFrequency=22050, const float minFrequency=20, const float sampleRate=44100, const float tolerance=0.15); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _pitchyin; +}; + +class PitchYinFFT { + public: + PitchYinFFT(const int frameSize=2048, const bool interpolate=true, const float maxFrequency=22050, const float minFrequency=20, const float sampleRate=44100, const float tolerance=1); + ~PitchYinFFT(); + void configure(const int frameSize=2048, const bool interpolate=true, const float maxFrequency=22050, const float minFrequency=20, const float sampleRate=44100, const float tolerance=1); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _pitchyinfft; +}; + +class PitchYinProbabilistic { + public: + PitchYinProbabilistic(const int frameSize=2048, const int hopSize=256, const float lowRMSThreshold=0.1, const std::string& outputUnvoiced="negative", const bool preciseTime=false, const float sampleRate=44100); + ~PitchYinProbabilistic(); + void configure(const int frameSize=2048, const int hopSize=256, const float lowRMSThreshold=0.1, const std::string& outputUnvoiced="negative", const bool preciseTime=false, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _pitchyinprobabilistic; +}; + +class PitchYinProbabilities { + public: + PitchYinProbabilities(const int frameSize=2048, const float lowAmp=0.1, const bool preciseTime=false, const float sampleRate=44100); + ~PitchYinProbabilities(); + void configure(const int frameSize=2048, const float lowAmp=0.1, const bool preciseTime=false, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _pitchyinprobabilities; +}; + +class PitchYinProbabilitiesHMM { + public: + PitchYinProbabilitiesHMM(const float minFrequency=61.735, const int numberBinsPerSemitone=5, const float selfTransition=0.99, const float yinTrust=0.5); + ~PitchYinProbabilitiesHMM(); + void configure(const float minFrequency=61.735, const int numberBinsPerSemitone=5, const float selfTransition=0.99, const float yinTrust=0.5); + val compute(std::vector >& input_pitchCandidates, std::vector >& input_probabilities); + void reset(); + private: + Algorithm* _pitchyinprobabilitieshmm; +}; + +class PowerMean { + public: + PowerMean(const float power=1); + ~PowerMean(); + void configure(const float power=1); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _powermean; +}; + +class PowerSpectrum { + public: + PowerSpectrum(const int size=2048); + ~PowerSpectrum(); + void configure(const int size=2048); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _powerspectrum; +}; + +class PredominantPitchMelodia { + public: + PredominantPitchMelodia(const float binResolution=10, const int filterIterations=3, const int frameSize=2048, const bool guessUnvoiced=false, const float harmonicWeight=0.8, const int hopSize=128, const float magnitudeCompression=1, const int magnitudeThreshold=40, const float maxFrequency=20000, const int minDuration=100, const float minFrequency=80, const int numberHarmonics=20, const float peakDistributionThreshold=0.9, const float peakFrameThreshold=0.9, const float pitchContinuity=27.5625, const float referenceFrequency=55, const float sampleRate=44100, const int timeContinuity=100, const bool voiceVibrato=false, const float voicingTolerance=0.2); + ~PredominantPitchMelodia(); + void configure(const float binResolution=10, const int filterIterations=3, const int frameSize=2048, const bool guessUnvoiced=false, const float harmonicWeight=0.8, const int hopSize=128, const float magnitudeCompression=1, const int magnitudeThreshold=40, const float maxFrequency=20000, const int minDuration=100, const float minFrequency=80, const int numberHarmonics=20, const float peakDistributionThreshold=0.9, const float peakFrameThreshold=0.9, const float pitchContinuity=27.5625, const float referenceFrequency=55, const float sampleRate=44100, const int timeContinuity=100, const bool voiceVibrato=false, const float voicingTolerance=0.2); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _predominantpitchmelodia; +}; + +class RMS { + public: + RMS(); + ~RMS(); + void configure(); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _rms; +}; + +class RawMoments { + public: + RawMoments(const float range=22050); + ~RawMoments(); + void configure(const float range=22050); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _rawmoments; +}; + +class ReplayGain { + public: + ReplayGain(const float sampleRate=44100); + ~ReplayGain(); + void configure(const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _replaygain; +}; + +class Resample { + public: + Resample(const float inputSampleRate=44100, const float outputSampleRate=44100, const int quality=1); + ~Resample(); + void configure(const float inputSampleRate=44100, const float outputSampleRate=44100, const int quality=1); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _resample; +}; + +class ResampleFFT { + public: + ResampleFFT(const int inSize=128, const int outSize=128); + ~ResampleFFT(); + void configure(const int inSize=128, const int outSize=128); + val compute(std::vector& input_input); + void reset(); + private: + Algorithm* _resamplefft; +}; + +class RhythmDescriptors { + public: + RhythmDescriptors(); + ~RhythmDescriptors(); + void configure(); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _rhythmdescriptors; +}; + +class RhythmExtractor { + public: + RhythmExtractor(const int frameHop=1024, const int frameSize=1024, const int hopSize=256, const float lastBeatInterval=0.1, const int maxTempo=208, const int minTempo=40, const int numberFrames=1024, const float sampleRate=44100, const std::vector& tempoHints=std::vector(), const float tolerance=0.24, const bool useBands=true, const bool useOnset=true); + ~RhythmExtractor(); + void configure(const int frameHop=1024, const int frameSize=1024, const int hopSize=256, const float lastBeatInterval=0.1, const int maxTempo=208, const int minTempo=40, const int numberFrames=1024, const float sampleRate=44100, const std::vector& tempoHints=std::vector(), const float tolerance=0.24, const bool useBands=true, const bool useOnset=true); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _rhythmextractor; +}; + +class RhythmExtractor2013 { + public: + RhythmExtractor2013(const int maxTempo=208, const std::string& method="multifeature", const int minTempo=40); + ~RhythmExtractor2013(); + void configure(const int maxTempo=208, const std::string& method="multifeature", const int minTempo=40); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _rhythmextractor2013; +}; + +class RhythmTransform { + public: + RhythmTransform(const int frameSize=256, const int hopSize=32); + ~RhythmTransform(); + void configure(const int frameSize=256, const int hopSize=32); + val compute(std::vector >& input_melBands); + void reset(); + private: + Algorithm* _rhythmtransform; +}; + +class RollOff { + public: + RollOff(const float cutoff=0.85, const float sampleRate=44100); + ~RollOff(); + void configure(const float cutoff=0.85, const float sampleRate=44100); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _rolloff; +}; + +class SNR { + public: + SNR(const float MAAlpha=0.95, const float MMSEAlpha=0.98, const float NoiseAlpha=0.9, const int frameSize=512, const float noiseThreshold=-40, const float sampleRate=44100, const bool useBroadbadNoiseCorrection=true); + ~SNR(); + void configure(const float MAAlpha=0.95, const float MMSEAlpha=0.98, const float NoiseAlpha=0.9, const int frameSize=512, const float noiseThreshold=-40, const float sampleRate=44100, const bool useBroadbadNoiseCorrection=true); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _snr; +}; + +class SaturationDetector { + public: + SaturationDetector(const float differentialThreshold=0.001, const float energyThreshold=-1, const int frameSize=512, const int hopSize=256, const float minimumDuration=0.005, const float sampleRate=44100); + ~SaturationDetector(); + void configure(const float differentialThreshold=0.001, const float energyThreshold=-1, const int frameSize=512, const int hopSize=256, const float minimumDuration=0.005, const float sampleRate=44100); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _saturationdetector; +}; + +class Scale { + public: + Scale(const bool clipping=true, const float factor=10, const float maxAbsValue=1); + ~Scale(); + void configure(const bool clipping=true, const float factor=10, const float maxAbsValue=1); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _scale; +}; + +class SineSubtraction { + public: + SineSubtraction(const int fftSize=512, const int hopSize=128, const float sampleRate=44100); + ~SineSubtraction(); + void configure(const int fftSize=512, const int hopSize=128, const float sampleRate=44100); + val compute(std::vector& input_frame, std::vector& input_magnitudes, std::vector& input_frequencies, std::vector& input_phases); + void reset(); + private: + Algorithm* _sinesubtraction; +}; + +class SingleBeatLoudness { + public: + SingleBeatLoudness(const float beatDuration=0.05, const float beatWindowDuration=0.1, const std::vector& frequencyBands=std::vector{0, 200, 400, 800, 1600, 3200, 22000}, const std::string& onsetStart="sumEnergy", const float sampleRate=44100); + ~SingleBeatLoudness(); + void configure(const float beatDuration=0.05, const float beatWindowDuration=0.1, const std::vector& frequencyBands=std::vector{0, 200, 400, 800, 1600, 3200, 22000}, const std::string& onsetStart="sumEnergy", const float sampleRate=44100); + val compute(std::vector& input_beat); + void reset(); + private: + Algorithm* _singlebeatloudness; +}; + +class Slicer { + public: + Slicer(const std::vector& endTimes=std::vector(), const float sampleRate=44100, const std::vector& startTimes=std::vector(), const std::string& timeUnits="seconds"); + ~Slicer(); + void configure(const std::vector& endTimes=std::vector(), const float sampleRate=44100, const std::vector& startTimes=std::vector(), const std::string& timeUnits="seconds"); + val compute(std::vector& input_audio); + void reset(); + private: + Algorithm* _slicer; +}; + +class SpectralCentroidTime { + public: + SpectralCentroidTime(const float sampleRate=44100); + ~SpectralCentroidTime(); + void configure(const float sampleRate=44100); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _spectralcentroidtime; +}; + +class SpectralComplexity { + public: + SpectralComplexity(const float magnitudeThreshold=0.005, const float sampleRate=44100); + ~SpectralComplexity(); + void configure(const float magnitudeThreshold=0.005, const float sampleRate=44100); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _spectralcomplexity; +}; + +class SpectralContrast { + public: + SpectralContrast(const int frameSize=2048, const float highFrequencyBound=11000, const float lowFrequencyBound=20, const float neighbourRatio=0.4, const int numberBands=6, const float sampleRate=22050, const float staticDistribution=0.15); + ~SpectralContrast(); + void configure(const int frameSize=2048, const float highFrequencyBound=11000, const float lowFrequencyBound=20, const float neighbourRatio=0.4, const int numberBands=6, const float sampleRate=22050, const float staticDistribution=0.15); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _spectralcontrast; +}; + +class SpectralPeaks { + public: + SpectralPeaks(const float magnitudeThreshold=0, const float maxFrequency=5000, const int maxPeaks=100, const float minFrequency=0, const std::string& orderBy="frequency", const float sampleRate=44100); + ~SpectralPeaks(); + void configure(const float magnitudeThreshold=0, const float maxFrequency=5000, const int maxPeaks=100, const float minFrequency=0, const std::string& orderBy="frequency", const float sampleRate=44100); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _spectralpeaks; +}; + +class SpectralWhitening { + public: + SpectralWhitening(const float maxFrequency=5000, const float sampleRate=44100); + ~SpectralWhitening(); + void configure(const float maxFrequency=5000, const float sampleRate=44100); + val compute(std::vector& input_spectrum, std::vector& input_frequencies, std::vector& input_magnitudes); + void reset(); + private: + Algorithm* _spectralwhitening; +}; + +class Spectrum { + public: + Spectrum(const int size=2048); + ~Spectrum(); + void configure(const int size=2048); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _spectrum; +}; + +class SpectrumCQ { + public: + SpectrumCQ(const int binsPerOctave=12, const float minFrequency=32.7, const int minimumKernelSize=4, const int numberBins=84, const float sampleRate=44100, const float scale=1, const float threshold=0.01, const std::string& windowType="hann", const bool zeroPhase=true); + ~SpectrumCQ(); + void configure(const int binsPerOctave=12, const float minFrequency=32.7, const int minimumKernelSize=4, const int numberBins=84, const float sampleRate=44100, const float scale=1, const float threshold=0.01, const std::string& windowType="hann", const bool zeroPhase=true); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _spectrumcq; +}; + +class SpectrumToCent { + public: + SpectrumToCent(const int bands=720, const float centBinResolution=10, const int inputSize=32768, const bool log=true, const float minimumFrequency=164, const std::string& normalize="unit_sum", const float sampleRate=44100, const std::string& type="power"); + ~SpectrumToCent(); + void configure(const int bands=720, const float centBinResolution=10, const int inputSize=32768, const bool log=true, const float minimumFrequency=164, const std::string& normalize="unit_sum", const float sampleRate=44100, const std::string& type="power"); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _spectrumtocent; +}; + +class Spline { + public: + Spline(const float beta1=1, const float beta2=0, const std::string& type="b", const std::vector& xPoints=std::vector{0, 1}, const std::vector& yPoints=std::vector{0, 1}); + ~Spline(); + void configure(const float beta1=1, const float beta2=0, const std::string& type="b", const std::vector& xPoints=std::vector{0, 1}, const std::vector& yPoints=std::vector{0, 1}); + val compute(float input_x); + void reset(); + private: + Algorithm* _spline; +}; + +class SprModelAnal { + public: + SprModelAnal(const int fftSize=2048, const int freqDevOffset=20, const float freqDevSlope=0.01, const int hopSize=512, const float magnitudeThreshold=0, const float maxFrequency=5000, const int maxPeaks=100, const int maxnSines=100, const float minFrequency=0, const std::string& orderBy="frequency", const float sampleRate=44100); + ~SprModelAnal(); + void configure(const int fftSize=2048, const int freqDevOffset=20, const float freqDevSlope=0.01, const int hopSize=512, const float magnitudeThreshold=0, const float maxFrequency=5000, const int maxPeaks=100, const int maxnSines=100, const float minFrequency=0, const std::string& orderBy="frequency", const float sampleRate=44100); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _sprmodelanal; +}; + +class SprModelSynth { + public: + SprModelSynth(const int fftSize=2048, const int hopSize=512, const float sampleRate=44100); + ~SprModelSynth(); + void configure(const int fftSize=2048, const int hopSize=512, const float sampleRate=44100); + val compute(std::vector& input_magnitudes, std::vector& input_frequencies, std::vector& input_phases, std::vector& input_res); + void reset(); + private: + Algorithm* _sprmodelsynth; +}; + +class SpsModelAnal { + public: + SpsModelAnal(const int fftSize=2048, const int freqDevOffset=20, const float freqDevSlope=0.01, const int hopSize=512, const float magnitudeThreshold=0, const float maxFrequency=5000, const int maxPeaks=100, const int maxnSines=100, const float minFrequency=0, const std::string& orderBy="frequency", const float sampleRate=44100, const float stocf=0.2); + ~SpsModelAnal(); + void configure(const int fftSize=2048, const int freqDevOffset=20, const float freqDevSlope=0.01, const int hopSize=512, const float magnitudeThreshold=0, const float maxFrequency=5000, const int maxPeaks=100, const int maxnSines=100, const float minFrequency=0, const std::string& orderBy="frequency", const float sampleRate=44100, const float stocf=0.2); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _spsmodelanal; +}; + +class SpsModelSynth { + public: + SpsModelSynth(const int fftSize=2048, const int hopSize=512, const float sampleRate=44100, const float stocf=0.2); + ~SpsModelSynth(); + void configure(const int fftSize=2048, const int hopSize=512, const float sampleRate=44100, const float stocf=0.2); + val compute(std::vector& input_magnitudes, std::vector& input_frequencies, std::vector& input_phases, std::vector& input_stocenv); + void reset(); + private: + Algorithm* _spsmodelsynth; +}; + +class StartStopCut { + public: + StartStopCut(const int frameSize=256, const int hopSize=256, const float maximumStartTime=10, const float maximumStopTime=10, const float sampleRate=44100, const int threshold=-60); + ~StartStopCut(); + void configure(const int frameSize=256, const int hopSize=256, const float maximumStartTime=10, const float maximumStopTime=10, const float sampleRate=44100, const int threshold=-60); + val compute(std::vector& input_audio); + void reset(); + private: + Algorithm* _startstopcut; +}; + +class StartStopSilence { + public: + StartStopSilence(const int threshold=-60); + ~StartStopSilence(); + void configure(const int threshold=-60); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _startstopsilence; +}; + +class StochasticModelAnal { + public: + StochasticModelAnal(const int fftSize=2048, const int hopSize=512, const float sampleRate=44100, const float stocf=0.2); + ~StochasticModelAnal(); + void configure(const int fftSize=2048, const int hopSize=512, const float sampleRate=44100, const float stocf=0.2); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _stochasticmodelanal; +}; + +class StochasticModelSynth { + public: + StochasticModelSynth(const int fftSize=2048, const int hopSize=512, const float sampleRate=44100, const float stocf=0.2); + ~StochasticModelSynth(); + void configure(const int fftSize=2048, const int hopSize=512, const float sampleRate=44100, const float stocf=0.2); + val compute(std::vector& input_stocenv); + void reset(); + private: + Algorithm* _stochasticmodelsynth; +}; + +class StrongDecay { + public: + StrongDecay(const float sampleRate=44100); + ~StrongDecay(); + void configure(const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _strongdecay; +}; + +class StrongPeak { + public: + StrongPeak(); + ~StrongPeak(); + void configure(); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _strongpeak; +}; + +class SuperFluxExtractor { + public: + SuperFluxExtractor(const float combine=20, const int frameSize=2048, const int hopSize=256, const float ratioThreshold=16, const float sampleRate=44100, const float threshold=0.05); + ~SuperFluxExtractor(); + void configure(const float combine=20, const int frameSize=2048, const int hopSize=256, const float ratioThreshold=16, const float sampleRate=44100, const float threshold=0.05); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _superfluxextractor; +}; + +class SuperFluxNovelty { + public: + SuperFluxNovelty(const int binWidth=3, const int frameWidth=2); + ~SuperFluxNovelty(); + void configure(const int binWidth=3, const int frameWidth=2); + val compute(std::vector >& input_bands); + void reset(); + private: + Algorithm* _superfluxnovelty; +}; + +class SuperFluxPeaks { + public: + SuperFluxPeaks(const float combine=30, const float frameRate=172, const float pre_avg=100, const float pre_max=30, const float ratioThreshold=16, const float threshold=0.05); + ~SuperFluxPeaks(); + void configure(const float combine=30, const float frameRate=172, const float pre_avg=100, const float pre_max=30, const float ratioThreshold=16, const float threshold=0.05); + val compute(std::vector& input_novelty); + void reset(); + private: + Algorithm* _superfluxpeaks; +}; + +class TCToTotal { + public: + TCToTotal(); + ~TCToTotal(); + void configure(); + val compute(std::vector& input_envelope); + void reset(); + private: + Algorithm* _tctototal; +}; + +class TempoScaleBands { + public: + TempoScaleBands(const std::vector& bandsGain=std::vector{2, 3, 2, 1, 1.20000004768, 2, 3, 2.5}, const float frameTime=512); + ~TempoScaleBands(); + void configure(const std::vector& bandsGain=std::vector{2, 3, 2, 1, 1.20000004768, 2, 3, 2.5}, const float frameTime=512); + val compute(std::vector& input_bands); + void reset(); + private: + Algorithm* _temposcalebands; +}; + +class TempoTap { + public: + TempoTap(const int frameHop=1024, const int frameSize=256, const int maxTempo=208, const int minTempo=40, const int numberFrames=1024, const float sampleRate=44100, const std::vector& tempoHints=std::vector()); + ~TempoTap(); + void configure(const int frameHop=1024, const int frameSize=256, const int maxTempo=208, const int minTempo=40, const int numberFrames=1024, const float sampleRate=44100, const std::vector& tempoHints=std::vector()); + val compute(std::vector& input_featuresFrame); + void reset(); + private: + Algorithm* _tempotap; +}; + +class TempoTapDegara { + public: + TempoTapDegara(const int maxTempo=208, const int minTempo=40, const std::string& resample="none", const float sampleRateODF=86.1328); + ~TempoTapDegara(); + void configure(const int maxTempo=208, const int minTempo=40, const std::string& resample="none", const float sampleRateODF=86.1328); + val compute(std::vector& input_onsetDetections); + void reset(); + private: + Algorithm* _tempotapdegara; +}; + +class TempoTapMaxAgreement { + public: + TempoTapMaxAgreement(); + ~TempoTapMaxAgreement(); + void configure(); + val compute(std::vector >& input_tickCandidates); + void reset(); + private: + Algorithm* _tempotapmaxagreement; +}; + +class TempoTapTicks { + public: + TempoTapTicks(const int frameHop=512, const int hopSize=256, const float sampleRate=44100); + ~TempoTapTicks(); + void configure(const int frameHop=512, const int hopSize=256, const float sampleRate=44100); + val compute(std::vector& input_periods, std::vector& input_phases); + void reset(); + private: + Algorithm* _tempotapticks; +}; + +class TensorflowInputFSDSINet { + public: + TensorflowInputFSDSINet(); + ~TensorflowInputFSDSINet(); + void configure(); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _tensorflowinputfsdsinet; +}; + +class TensorflowInputMusiCNN { + public: + TensorflowInputMusiCNN(); + ~TensorflowInputMusiCNN(); + void configure(); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _tensorflowinputmusicnn; +}; + +class TensorflowInputTempoCNN { + public: + TensorflowInputTempoCNN(); + ~TensorflowInputTempoCNN(); + void configure(); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _tensorflowinputtempocnn; +}; + +class TensorflowInputVGGish { + public: + TensorflowInputVGGish(); + ~TensorflowInputVGGish(); + void configure(); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _tensorflowinputvggish; +}; + +class TonalExtractor { + public: + TonalExtractor(const int frameSize=4096, const int hopSize=2048, const float tuningFrequency=440); + ~TonalExtractor(); + void configure(const int frameSize=4096, const int hopSize=2048, const float tuningFrequency=440); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _tonalextractor; +}; + +class TonicIndianArtMusic { + public: + TonicIndianArtMusic(const float binResolution=10, const int frameSize=2048, const float harmonicWeight=0.85, const int hopSize=512, const float magnitudeCompression=1, const float magnitudeThreshold=40, const float maxTonicFrequency=375, const float minTonicFrequency=100, const int numberHarmonics=20, const int numberSaliencePeaks=5, const float referenceFrequency=55, const float sampleRate=44100); + ~TonicIndianArtMusic(); + void configure(const float binResolution=10, const int frameSize=2048, const float harmonicWeight=0.85, const int hopSize=512, const float magnitudeCompression=1, const float magnitudeThreshold=40, const float maxTonicFrequency=375, const float minTonicFrequency=100, const int numberHarmonics=20, const int numberSaliencePeaks=5, const float referenceFrequency=55, const float sampleRate=44100); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _tonicindianartmusic; +}; + +class TriangularBands { + public: + TriangularBands(const std::vector& frequencyBands=std::vector{21.533203125, 43.06640625, 64.599609375, 86.1328125, 107.666015625, 129.19921875, 150.732421875, 172.265625, 193.798828125, 215.33203125, 236.865234375, 258.3984375, 279.931640625, 301.46484375, 322.998046875, 344.53125, 366.064453125, 387.59765625, 409.130859375, 430.6640625, 452.197265625, 473.73046875, 495.263671875, 516.796875, 538.330078125, 559.86328125, 581.396484375, 602.9296875, 624.462890625, 645.99609375, 667.529296875, 689.0625, 710.595703125, 732.12890625, 753.662109375, 775.1953125, 796.728515625, 839.794921875, 861.328125, 882.861328125, 904.39453125, 925.927734375, 968.994140625, 990.52734375, 1012.06054688, 1055.12695312, 1076.66015625, 1098.19335938, 1141.25976562, 1184.32617188, 1205.859375, 1248.92578125, 1270.45898438, 1313.52539062, 1356.59179688, 1399.65820312, 1442.72460938, 1485.79101562, 1528.85742188, 1571.92382812, 1614.99023438, 1658.05664062, 1701.12304688, 1765.72265625, 1808.7890625, 1873.38867188, 1916.45507812, 1981.0546875, 2024.12109375, 2088.72070312, 2153.3203125, 2217.91992188, 2282.51953125, 2347.11914062, 2411.71875, 2497.8515625, 2562.45117188, 2627.05078125, 2713.18359375, 2799.31640625, 2885.44921875, 2950.04882812, 3036.18164062, 3143.84765625, 3229.98046875, 3316.11328125, 3423.77929688, 3509.91210938, 3617.578125, 3725.24414062, 3832.91015625, 3940.57617188, 4069.77539062, 4177.44140625, 4306.640625, 4435.83984375, 4565.0390625, 4694.23828125, 4844.97070312, 4974.16992188, 5124.90234375, 5275.63476562, 5426.3671875, 5577.09960938, 5749.36523438, 5921.63085938, 6093.89648438, 6266.16210938, 6459.9609375, 6653.75976562, 6847.55859375, 7041.35742188, 7256.68945312, 7450.48828125, 7687.35351562, 7902.68554688, 8139.55078125, 8376.41601562, 8613.28125, 8871.6796875, 9130.078125, 9388.4765625, 9668.40820312, 9948.33984375, 10249.8046875, 10551.2695312, 10852.734375, 11175.7324219, 11498.7304688, 11843.2617188, 12187.7929688, 12553.8574219, 12919.921875, 13285.9863281, 13673.5839844, 14082.7148438, 14491.8457031, 14922.5097656, 15353.1738281, 15805.3710938, 16257.5683594}, const int inputSize=1025, const bool log=true, const std::string& normalize="unit_sum", const float sampleRate=44100, const std::string& type="power", const std::string& weighting="linear"); + ~TriangularBands(); + void configure(const std::vector& frequencyBands=std::vector{21.533203125, 43.06640625, 64.599609375, 86.1328125, 107.666015625, 129.19921875, 150.732421875, 172.265625, 193.798828125, 215.33203125, 236.865234375, 258.3984375, 279.931640625, 301.46484375, 322.998046875, 344.53125, 366.064453125, 387.59765625, 409.130859375, 430.6640625, 452.197265625, 473.73046875, 495.263671875, 516.796875, 538.330078125, 559.86328125, 581.396484375, 602.9296875, 624.462890625, 645.99609375, 667.529296875, 689.0625, 710.595703125, 732.12890625, 753.662109375, 775.1953125, 796.728515625, 839.794921875, 861.328125, 882.861328125, 904.39453125, 925.927734375, 968.994140625, 990.52734375, 1012.06054688, 1055.12695312, 1076.66015625, 1098.19335938, 1141.25976562, 1184.32617188, 1205.859375, 1248.92578125, 1270.45898438, 1313.52539062, 1356.59179688, 1399.65820312, 1442.72460938, 1485.79101562, 1528.85742188, 1571.92382812, 1614.99023438, 1658.05664062, 1701.12304688, 1765.72265625, 1808.7890625, 1873.38867188, 1916.45507812, 1981.0546875, 2024.12109375, 2088.72070312, 2153.3203125, 2217.91992188, 2282.51953125, 2347.11914062, 2411.71875, 2497.8515625, 2562.45117188, 2627.05078125, 2713.18359375, 2799.31640625, 2885.44921875, 2950.04882812, 3036.18164062, 3143.84765625, 3229.98046875, 3316.11328125, 3423.77929688, 3509.91210938, 3617.578125, 3725.24414062, 3832.91015625, 3940.57617188, 4069.77539062, 4177.44140625, 4306.640625, 4435.83984375, 4565.0390625, 4694.23828125, 4844.97070312, 4974.16992188, 5124.90234375, 5275.63476562, 5426.3671875, 5577.09960938, 5749.36523438, 5921.63085938, 6093.89648438, 6266.16210938, 6459.9609375, 6653.75976562, 6847.55859375, 7041.35742188, 7256.68945312, 7450.48828125, 7687.35351562, 7902.68554688, 8139.55078125, 8376.41601562, 8613.28125, 8871.6796875, 9130.078125, 9388.4765625, 9668.40820312, 9948.33984375, 10249.8046875, 10551.2695312, 10852.734375, 11175.7324219, 11498.7304688, 11843.2617188, 12187.7929688, 12553.8574219, 12919.921875, 13285.9863281, 13673.5839844, 14082.7148438, 14491.8457031, 14922.5097656, 15353.1738281, 15805.3710938, 16257.5683594}, const int inputSize=1025, const bool log=true, const std::string& normalize="unit_sum", const float sampleRate=44100, const std::string& type="power", const std::string& weighting="linear"); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _triangularbands; +}; + +class TriangularBarkBands { + public: + TriangularBarkBands(const float highFrequencyBound=22050, const int inputSize=1025, const bool log=false, const float lowFrequencyBound=0, const std::string& normalize="unit_sum", const int numberBands=24, const float sampleRate=44100, const std::string& type="power", const std::string& weighting="warping"); + ~TriangularBarkBands(); + void configure(const float highFrequencyBound=22050, const int inputSize=1025, const bool log=false, const float lowFrequencyBound=0, const std::string& normalize="unit_sum", const int numberBands=24, const float sampleRate=44100, const std::string& type="power", const std::string& weighting="warping"); + val compute(std::vector& input_spectrum); + void reset(); + private: + Algorithm* _triangularbarkbands; +}; + +class Trimmer { + public: + Trimmer(const bool checkRange=false, const float endTime=1e+06, const float sampleRate=44100, const float startTime=0); + ~Trimmer(); + void configure(const bool checkRange=false, const float endTime=1e+06, const float sampleRate=44100, const float startTime=0); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _trimmer; +}; + +class Tristimulus { + public: + Tristimulus(); + ~Tristimulus(); + void configure(); + val compute(std::vector& input_frequencies, std::vector& input_magnitudes); + void reset(); + private: + Algorithm* _tristimulus; +}; + +class TruePeakDetector { + public: + TruePeakDetector(const bool blockDC=false, const bool emphasise=false, const int oversamplingFactor=4, const int quality=1, const float sampleRate=44100, const float threshold=-0.0002, const int version=4); + ~TruePeakDetector(); + void configure(const bool blockDC=false, const bool emphasise=false, const int oversamplingFactor=4, const int quality=1, const float sampleRate=44100, const float threshold=-0.0002, const int version=4); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _truepeakdetector; +}; + +class TuningFrequency { + public: + TuningFrequency(const float resolution=1); + ~TuningFrequency(); + void configure(const float resolution=1); + val compute(std::vector& input_frequencies, std::vector& input_magnitudes); + void reset(); + private: + Algorithm* _tuningfrequency; +}; + +class TuningFrequencyExtractor { + public: + TuningFrequencyExtractor(const int frameSize=4096, const int hopSize=2048); + ~TuningFrequencyExtractor(); + void configure(const int frameSize=4096, const int hopSize=2048); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _tuningfrequencyextractor; +}; + +class UnaryOperator { + public: + UnaryOperator(const float scale=1, const float shift=0, const std::string& type="identity"); + ~UnaryOperator(); + void configure(const float scale=1, const float shift=0, const std::string& type="identity"); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _unaryoperator; +}; + +class UnaryOperatorStream { + public: + UnaryOperatorStream(const float scale=1, const float shift=0, const std::string& type="identity"); + ~UnaryOperatorStream(); + void configure(const float scale=1, const float shift=0, const std::string& type="identity"); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _unaryoperatorstream; +}; + +class Variance { + public: + Variance(); + ~Variance(); + void configure(); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _variance; +}; + +class Vibrato { + public: + Vibrato(const float maxExtend=250, const float maxFrequency=8, const float minExtend=50, const float minFrequency=4, const float sampleRate=344.531); + ~Vibrato(); + void configure(const float maxExtend=250, const float maxFrequency=8, const float minExtend=50, const float minFrequency=4, const float sampleRate=344.531); + val compute(std::vector& input_pitch); + void reset(); + private: + Algorithm* _vibrato; +}; + +class WarpedAutoCorrelation { + public: + WarpedAutoCorrelation(const int maxLag=1, const float sampleRate=44100); + ~WarpedAutoCorrelation(); + void configure(const int maxLag=1, const float sampleRate=44100); + val compute(std::vector& input_array); + void reset(); + private: + Algorithm* _warpedautocorrelation; +}; + +class Welch { + public: + Welch(const int averagingFrames=10, const int fftSize=1024, const int frameSize=512, const float sampleRate=44100, const std::string& scaling="density", const std::string& windowType="hann"); + ~Welch(); + void configure(const int averagingFrames=10, const int fftSize=1024, const int frameSize=512, const float sampleRate=44100, const std::string& scaling="density", const std::string& windowType="hann"); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _welch; +}; + +class Windowing { + public: + Windowing(const int constantsDecimals=5, const bool normalized=true, const int size=1024, const bool splitPadding=false, const bool symmetric=true, const std::string& type="hann", const int zeroPadding=0, const bool zeroPhase=true); + ~Windowing(); + void configure(const int constantsDecimals=5, const bool normalized=true, const int size=1024, const bool splitPadding=false, const bool symmetric=true, const std::string& type="hann", const int zeroPadding=0, const bool zeroPhase=true); + val compute(std::vector& input_frame); + void reset(); + private: + Algorithm* _windowing; +}; + +class ZeroCrossingRate { + public: + ZeroCrossingRate(const float threshold=0); + ~ZeroCrossingRate(); + void configure(const float threshold=0); + val compute(std::vector& input_signal); + void reset(); + private: + Algorithm* _zerocrossingrate; }; // convert a Float32 JS typed array into std::vector diff --git a/src/python/code_generator.py b/src/python/code_generator.py index 75d915c..9ccdb01 100644 --- a/src/python/code_generator.py +++ b/src/python/code_generator.py @@ -142,34 +142,28 @@ def parse_algorithm_info(algorithm_name, target="header"): OUTPUT_PREFIX_ES, out['name'])) - # Default function declaration string - func_str = "%s %s(%s, %s)" % (FUNC_RETURN_TYPE, - algorithm_name, - ', '.join(inputs), - ', '.join(parameters)) - - # Update the func_str if either inputs or parameters + # Default class declaration string + class_str = f""" +class {algorithm_name} {{ + public: + {algorithm_name}({', '.join(parameters)}); + ~{algorithm_name}(); + void configure({', '.join(parameters)}); + {FUNC_RETURN_TYPE} compute({', '.join(inputs)}); + void reset(); + private: + Algorithm* _{algorithm_name.lower()}; +}};""" + + # Update the class_str if either inputs or parameters # are not specified for a particular algorithms - if not inputs: - - func_str = "%s %s(%s)" % (FUNC_RETURN_TYPE, - algorithm_name, - ', '.join(parameters)) - - if not parameters and not outputs: - raise IOError("No inputs, outputs or parameters found for the algorithm - '%s'" - % algorithm_name) - - if not parameters: - - func_str = "%s %s(%s)" % (FUNC_RETURN_TYPE, - algorithm_name, - ', '.join(inputs)) + if not inputs and not parameters and not outputs: + raise IOError(f"No inputs, outputs or parameters found for the algorithm - '{algorithm_name}'") - # return function declaration string if target is for header file + # return class declaration string if target is for header file if target == "header": - return func_str + return class_str # otherwise construct the algorithm method elif target == "algorithm": @@ -186,7 +180,7 @@ def parse_algorithm_info(algorithm_name, target="header"): algorithm.append("%s %s::%s%s {" % (FUNC_RETURN_TYPE, class_name, algorithm_name, - func_str.split(arg_parse_str)[1])) + class_str.split(arg_parse_str)[1])) algorithm.append(" AlgorithmFactory& factory = standard::AlgorithmFactory::instance();") @@ -235,16 +229,16 @@ def parse_algorithm_info(algorithm_name, target="header"): def generate_headers(algorithms=TO_INCLUDE_ALGOS): - """Generate a list of string where each of this string corresponds to the function declaration + """Generate a list of string where each of this string corresponds to the class declaration of each essentia algorithm in the target header file.""" - funcs = list() + classes = list() # we have bindings for 3 more extra algorithms with custom wrappers (MonoMixer, FrameCutter and LoudnessEBUR128) beside autogenerated ones. logging.info("Total %s algorithms" % (len(TO_INCLUDE_ALGOS) + 3)) logging.info("Generating essentiajs.h file ...") for algo_name in algorithms: logging.info(algo_name) - funcs.append(parse_algorithm_info(algo_name, target="header")) - return funcs + classes.append(parse_algorithm_info(algo_name, target="header")) + return classes def generate_algorithms(algorithms=TO_INCLUDE_ALGOS): diff --git a/src/python/configure_bindings.py b/src/python/configure_bindings.py index 9f5c914..620d2d7 100644 --- a/src/python/configure_bindings.py +++ b/src/python/configure_bindings.py @@ -1,6 +1,4 @@ # -*- coding: utf-8 -*- -from __future__ import print_function -from builtins import str import os import argparse import essentia.standard as estd @@ -32,6 +30,7 @@ def savelist_to_file(path_list, filename): # requires Gaia and Tensorflow dependencies 'GaiaTransform', 'MusicExtractorSVM', 'TensorflowPredict', 'TensorflowPredictMusiCNN', 'TensorflowPredictVGGish', + # expect tensor_real type 'TensorNormalize', 'TensorTranspose', # these algortihms expect a matrix_real input or output types which are not yet supported for the JS bindings 'BpmHistogram', 'FadeDetection', 'HumDetector', 'Onsets', 'Panning', 'SBic', 'SingleGaussian', diff --git a/src/python/header.cog b/src/python/header.cog index 3d0835a..09152bc 100644 --- a/src/python/header.cog +++ b/src/python/header.cog @@ -23,38 +23,45 @@ #define ESSENTIAJS_H #include +#include +#include +#include +using namespace essentia; +using namespace essentia::standard; using namespace emscripten; -class EssentiaJS { +void init(); + +// method for generating frames from a given audio signal +class FrameGenerator { public: - // property to store the current essentia library version - std::string essentiaVersion; - // constructor for instantiating the essentia algo registry with an optional argument to enable debug mode - EssentiaJS(bool debugger=false); - ~EssentiaJS(){}; - // method for shutdown essentia instance - void shutdown(); - // method for generating frames from a given audio signal - std::vector > FrameGenerator(const val& signalArray, int frameSize, int hopSize); - val MonoMixer(std::vector& left_channel, std::vector& right_channel); - val LoudnessEBUR128(std::vector& left_channel, std::vector& right_channel, const float hopSize=0.1, const float sampleRate=44100, const bool startAtZero=false); - // NOTE: The following code snippets are machine generated. Do not edit. - /*[[[cog - import cog - from code_generator import generate_headers, TO_INCLUDE_ALGOS - cog.outl(" ") - cog.outl("// class property which stores all the list of essentia algorithm names available in essentia.js") - c_algo_list = str(TO_INCLUDE_ALGOS) - cog.outl('std::string algorithmNames = "%s";' % c_algo_list) - cog.outl("// class methods to call various essentia algorithms") - headers = generate_headers() - for ln in headers: - cog.outl("%s;" % ln) - ]]]*/ - //[[[end]]] + FrameGenerator(int frameSize, int hopSize); + ~FrameGenerator(); + void configure(int frameSize, int hopSize); + std::vector< std::vector > compute(const val& signalArray); + void reset(); + private: + Algorithm* _framecutter; }; +// val MonoMixer(std::vector& left_channel, std::vector& right_channel); +// val LoudnessEBUR128(std::vector& left_channel, std::vector& right_channel, const float hopSize=0.1, const float sampleRate=44100, const bool startAtZero=false); +// NOTE: The following code snippets are machine generated. Do not edit. +/*[[[cog +import cog +from code_generator import generate_headers, TO_INCLUDE_ALGOS +cog.outl(" ") +cog.outl("// class property which stores all the list of essentia algorithm names available in essentia.js") +c_algo_list = str(TO_INCLUDE_ALGOS) +cog.outl(f'std::string algorithmNames = "{c_algo_list}";') +cog.outl("// class methods to call various essentia algorithms") +headers = generate_headers() +for ln in headers: + cog.outl(ln) +]]]*/ +//[[[end]]] + // convert a Float32 JS typed array into std::vector std::vector float32ArrayToVector(const val &arr); diff --git a/src/python/included_algos.md b/src/python/included_algos.md index 3c478e7..f58877d 100644 --- a/src/python/included_algos.md +++ b/src/python/included_algos.md @@ -178,6 +178,7 @@ TempoTap TempoTapDegara TempoTapMaxAgreement TempoTapTicks +TensorflowInputFSDSINet TensorflowInputMusiCNN TensorflowInputTempoCNN TensorflowInputVGGish From 03c2713650cd5af308b1aba2355a9123b51d0662 Mon Sep 17 00:00:00 2001 From: Jorge Marcos Date: Mon, 12 Feb 2024 18:52:28 +0100 Subject: [PATCH 02/18] add class-based essentia algo definition template (.cpp) --- src/cpp/includes/essentiajs.cpp | 8851 ++++++++++++++++++++----------- src/python/code_generator.py | 126 +- src/python/library.cog | 177 +- 3 files changed, 5780 insertions(+), 3374 deletions(-) diff --git a/src/cpp/includes/essentiajs.cpp b/src/cpp/includes/essentiajs.cpp index 2efef2d..495be48 100644 --- a/src/cpp/includes/essentiajs.cpp +++ b/src/cpp/includes/essentiajs.cpp @@ -19,13 +19,9 @@ // NOTE: This source code is machine-generated. -#include -#include #include #include "essentiajs.h" -using namespace essentia; -using namespace essentia::standard; // convert a Float32 JS typed array into std::vector // https://github.com/emscripten-core/emscripten/issues/5519#issuecomment-589702756 @@ -41,48 +37,32 @@ std::vector float32ArrayToVector(const val &arr) { return vec; } -// instantiating the essentia algo registry with an optional argument to enable debug mode -EssentiaJS::EssentiaJS(bool debugger) { - if (debugger) { - // if true sets essentia debugger active - // EAll is a special value in essentia that contains all modules - setDebugLevel(EAll); - unsetDebugLevel(EMemory | EConnectors); - // activate warnings - essentia::warningLevelActive = true; - // activate info - essentia::infoLevelActive = true; - // activate error level - essentia::errorLevelActive = true; - } else { - essentia::infoLevelActive = false; - essentia::warningLevelActive = false; - } - essentia::init(); - essentiaVersion = essentia::version; -} -// shutdown essentia instance -void EssentiaJS::shutdown() { - essentia::shutdown(); +// START FrameGenerator definitions +FrameGenerator::FrameGenerator(int frameSize, int hopSize) { + configure(frameSize, hopSize); } - -// Method for frameCutting the given audio signal -std::vector > EssentiaJS::FrameGenerator(const val& signalArray, int frameSize, int hopSize) { +FrameGenerator::~FrameGenerator() { + delete _framecutter; +} +void FrameGenerator::configure(int frameSize, int hopSize) { + // create algorithm instances + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _framecutter = factory.create("FrameCutter", + "frameSize", frameSize, + "hopSize", hopSize); +} +std::vector > FrameGenerator::compute(const val& signalArray) { // convert JS typed typed float 32 array to std::vector std::vector signal = float32ArrayToVector(signalArray); - // create algorithm instances - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* fc = factory.create("FrameCutter", - "frameSize", frameSize, - "hopSize", hopSize); + Pool pool; std::vector frame; - fc->input("signal").set(signal); - fc->output("frame").set(frame); + _framecutter->input("signal").set(signal); + _framecutter->output("frame").set(frame); while (true) { // compute a frame - fc->compute(); + _framecutter->compute(); // if it was the last one (ie: it was empty), then we're done. if (!frame.size()) { break; @@ -91,3389 +71,5834 @@ std::vector > EssentiaJS::FrameGenerator(const val& signalArr if (isSilent(frame)) continue; pool.add("frames", frame); } - delete fc; - return pool.value > >("frames"); + + return pool.value< std::vector > >("frames"); +} + +void FrameGenerator::reset() { + _framecutter->reset(); } +// END FrameGenerator definitions // This a wrapper for MonoMixer algorithm to accept both left and right channels to downmix an stereo channel input to mono // check https://essentia.upf.edu/reference/std_MonoMixer.html for algorithm details // TODO: could be reimplemented with BinaryOperator and UnaryOperator in the future -val EssentiaJS::MonoMixer(std::vector& left_channel, std::vector& right_channel) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); +// val EssentiaJS::MonoMixer(std::vector& left_channel, std::vector& right_channel) { +// AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - // TODO: remove this stereosample cresting overhead in future - Algorithm* algoStereoMuxer = factory.create("StereoMuxer"); - algoStereoMuxer->input("left").set(left_channel); - algoStereoMuxer->input("right").set(right_channel); - std::vector stereoSignal; - algoStereoMuxer->output("audio").set(stereoSignal); - algoStereoMuxer->compute(); - delete algoStereoMuxer; - - Algorithm* algoMonoMixer = factory.create("MonoMixer"); - std::vector output_audio; - algoMonoMixer->input("audio").set(stereoSignal); - // set numberChannels=2 since we only deal with stereo signal in this wrapper - algoMonoMixer->input("numberChannels").set(2); - algoMonoMixer->output("audio").set(output_audio); - algoMonoMixer->compute(); - - val outputMonoMixer(val::object()); - outputMonoMixer.set("audio", output_audio); - delete algoMonoMixer; - return outputMonoMixer; -}; +// // TODO: remove this stereosample cresting overhead in future +// Algorithm* algoStereoMuxer = factory.create("StereoMuxer"); +// algoStereoMuxer->input("left").set(left_channel); +// algoStereoMuxer->input("right").set(right_channel); +// std::vector stereoSignal; +// algoStereoMuxer->output("audio").set(stereoSignal); +// algoStereoMuxer->compute(); +// delete algoStereoMuxer; + +// Algorithm* algoMonoMixer = factory.create("MonoMixer"); +// std::vector output_audio; +// algoMonoMixer->input("audio").set(stereoSignal); +// // set numberChannels=2 since we only deal with stereo signal in this wrapper +// algoMonoMixer->input("numberChannels").set(2); +// algoMonoMixer->output("audio").set(output_audio); +// algoMonoMixer->compute(); + +// val outputMonoMixer(val::object()); +// outputMonoMixer.set("audio", output_audio); +// delete algoMonoMixer; +// return outputMonoMixer; +// }; // This a wrapper for LoudnessEBUR128 algorithm to accept both left and right channels of an stereo audio signal seperately // check https://essentia.upf.edu/reference/std_LoudnessEBUR128.html for algorithm details -val EssentiaJS::LoudnessEBUR128(std::vector& left_channel, std::vector& right_channel, const float hopSize, const float sampleRate, const bool startAtZero) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); +// val EssentiaJS::LoudnessEBUR128(std::vector& left_channel, std::vector& right_channel, const float hopSize, const float sampleRate, const bool startAtZero) { +// AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoStereoMuxer = factory.create("StereoMuxer"); - algoStereoMuxer->input("left").set(left_channel); - algoStereoMuxer->input("right").set(right_channel); - std::vector stereoSignal; - algoStereoMuxer->output("audio").set(stereoSignal); - algoStereoMuxer->compute(); - delete algoStereoMuxer; - - Algorithm* algoLoudnessEBUR128 = factory.create("LoudnessEBUR128", "hopSize", hopSize, "sampleRate", sampleRate, "startAtZero", startAtZero); - algoLoudnessEBUR128->input("signal").set(stereoSignal); - std::vector output_momentaryLoudness; - std::vector output_shortTermLoudness; - float output_integratedLoudness; - float output_loudnessRange; - algoLoudnessEBUR128->output("momentaryLoudness").set(output_momentaryLoudness); - algoLoudnessEBUR128->output("shortTermLoudness").set(output_shortTermLoudness); - algoLoudnessEBUR128->output("integratedLoudness").set(output_integratedLoudness); - algoLoudnessEBUR128->output("loudnessRange").set(output_loudnessRange); - algoLoudnessEBUR128->compute(); - val outputLoudnessEBUR128(val::object()); - outputLoudnessEBUR128.set("momentaryLoudness", output_momentaryLoudness); - outputLoudnessEBUR128.set("shortTermLoudness", output_shortTermLoudness); - outputLoudnessEBUR128.set("integratedLoudness", output_integratedLoudness); - outputLoudnessEBUR128.set("loudnessRange", output_loudnessRange); - - delete algoLoudnessEBUR128; - return outputLoudnessEBUR128; -} +// Algorithm* algoStereoMuxer = factory.create("StereoMuxer"); +// algoStereoMuxer->input("left").set(left_channel); +// algoStereoMuxer->input("right").set(right_channel); +// std::vector stereoSignal; +// algoStereoMuxer->output("audio").set(stereoSignal); +// algoStereoMuxer->compute(); +// delete algoStereoMuxer; + +// Algorithm* algoLoudnessEBUR128 = factory.create("LoudnessEBUR128", "hopSize", hopSize, "sampleRate", sampleRate, "startAtZero", startAtZero); +// algoLoudnessEBUR128->input("signal").set(stereoSignal); +// std::vector output_momentaryLoudness; +// std::vector output_shortTermLoudness; +// float output_integratedLoudness; +// float output_loudnessRange; +// algoLoudnessEBUR128->output("momentaryLoudness").set(output_momentaryLoudness); +// algoLoudnessEBUR128->output("shortTermLoudness").set(output_shortTermLoudness); +// algoLoudnessEBUR128->output("integratedLoudness").set(output_integratedLoudness); +// algoLoudnessEBUR128->output("loudnessRange").set(output_loudnessRange); +// algoLoudnessEBUR128->compute(); +// val outputLoudnessEBUR128(val::object()); +// outputLoudnessEBUR128.set("momentaryLoudness", output_momentaryLoudness); +// outputLoudnessEBUR128.set("shortTermLoudness", output_shortTermLoudness); +// outputLoudnessEBUR128.set("integratedLoudness", output_integratedLoudness); +// outputLoudnessEBUR128.set("loudnessRange", output_loudnessRange); + +// delete algoLoudnessEBUR128; +// return outputLoudnessEBUR128; +// } // NOTE: The following code snippets are machine generated. Do not edit. - + +// START AfterMaxToBeforeMaxEnergyRatio definitions // check https://essentia.upf.edu/reference/std_AfterMaxToBeforeMaxEnergyRatio.html -val EssentiaJS::AfterMaxToBeforeMaxEnergyRatio(std::vector& input_pitch) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoAfterMaxToBeforeMaxEnergyRatio = factory.create("AfterMaxToBeforeMaxEnergyRatio"); - algoAfterMaxToBeforeMaxEnergyRatio->input("pitch").set(input_pitch); - float output_afterMaxToBeforeMaxEnergyRatio; - algoAfterMaxToBeforeMaxEnergyRatio->output("afterMaxToBeforeMaxEnergyRatio").set(output_afterMaxToBeforeMaxEnergyRatio); - algoAfterMaxToBeforeMaxEnergyRatio->compute(); - val outputAfterMaxToBeforeMaxEnergyRatio(val::object()); - outputAfterMaxToBeforeMaxEnergyRatio.set("afterMaxToBeforeMaxEnergyRatio", output_afterMaxToBeforeMaxEnergyRatio); - delete algoAfterMaxToBeforeMaxEnergyRatio; - return outputAfterMaxToBeforeMaxEnergyRatio; -} - +AfterMaxToBeforeMaxEnergyRatio::AfterMaxToBeforeMaxEnergyRatio() { + configure(); +} +AfterMaxToBeforeMaxEnergyRatio::~AfterMaxToBeforeMaxEnergyRatio() { + delete _aftermaxtobeforemaxenergyratio; +} +void AfterMaxToBeforeMaxEnergyRatio::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _aftermaxtobeforemaxenergyratio = factory.create("AfterMaxToBeforeMaxEnergyRatio"); +} +val AfterMaxToBeforeMaxEnergyRatio::compute(std::vector& input_pitch) { + _aftermaxtobeforemaxenergyratio->input("pitch").set(input_pitch); + float output_afterMaxToBeforeMaxEnergyRatio; + _aftermaxtobeforemaxenergyratio->output("afterMaxToBeforeMaxEnergyRatio").set(output_afterMaxToBeforeMaxEnergyRatio); + _aftermaxtobeforemaxenergyratio->compute(); + val outputAfterMaxToBeforeMaxEnergyRatio(val::object()); + outputAfterMaxToBeforeMaxEnergyRatio.set("afterMaxToBeforeMaxEnergyRatio", output_afterMaxToBeforeMaxEnergyRatio); + return outputAfterMaxToBeforeMaxEnergyRatio; +} +void AfterMaxToBeforeMaxEnergyRatio::reset() { +_aftermaxtobeforemaxenergyratio->reset(); +} +// END AfterMaxToBeforeMaxEnergyRatio definitions + +// START AllPass definitions // check https://essentia.upf.edu/reference/std_AllPass.html -val EssentiaJS::AllPass(std::vector& input_signal, const float bandwidth, const float cutoffFrequency, const int order, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoAllPass = factory.create("AllPass", "bandwidth", bandwidth, "cutoffFrequency", cutoffFrequency, "order", order, "sampleRate", sampleRate); - algoAllPass->input("signal").set(input_signal); - std::vector output_signal; - algoAllPass->output("signal").set(output_signal); - algoAllPass->compute(); - val outputAllPass(val::object()); - outputAllPass.set("signal", output_signal); - delete algoAllPass; - return outputAllPass; -} - +AllPass::AllPass(const float bandwidth, const float cutoffFrequency, const int order, const float sampleRate) { + configure(bandwidth, cutoffFrequency, order, sampleRate); +} +AllPass::~AllPass() { + delete _allpass; +} +void AllPass::configure(const float bandwidth, const float cutoffFrequency, const int order, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _allpass = factory.create("AllPass", "bandwidth", bandwidth, "cutoffFrequency", cutoffFrequency, "order", order, "sampleRate", sampleRate); +} +val AllPass::compute(std::vector& input_signal) { + _allpass->input("signal").set(input_signal); + std::vector output_signal; + _allpass->output("signal").set(output_signal); + _allpass->compute(); + val outputAllPass(val::object()); + outputAllPass.set("signal", output_signal); + return outputAllPass; +} +void AllPass::reset() { +_allpass->reset(); +} +// END AllPass definitions + +// START AudioOnsetsMarker definitions // check https://essentia.upf.edu/reference/std_AudioOnsetsMarker.html -val EssentiaJS::AudioOnsetsMarker(std::vector& input_signal, const std::vector& onsets, const float sampleRate, const std::string& type) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoAudioOnsetsMarker = factory.create("AudioOnsetsMarker", "onsets", onsets, "sampleRate", sampleRate, "type", type); - algoAudioOnsetsMarker->input("signal").set(input_signal); - std::vector output_signal; - algoAudioOnsetsMarker->output("signal").set(output_signal); - algoAudioOnsetsMarker->compute(); - val outputAudioOnsetsMarker(val::object()); - outputAudioOnsetsMarker.set("signal", output_signal); - delete algoAudioOnsetsMarker; - return outputAudioOnsetsMarker; -} - +AudioOnsetsMarker::AudioOnsetsMarker(const std::vector& onsets, const float sampleRate, const std::string& type) { + configure(onsets, sampleRate, type); +} +AudioOnsetsMarker::~AudioOnsetsMarker() { + delete _audioonsetsmarker; +} +void AudioOnsetsMarker::configure(const std::vector& onsets, const float sampleRate, const std::string& type) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _audioonsetsmarker = factory.create("AudioOnsetsMarker", "onsets", onsets, "sampleRate", sampleRate, "type", type); +} +val AudioOnsetsMarker::compute(std::vector& input_signal) { + _audioonsetsmarker->input("signal").set(input_signal); + std::vector output_signal; + _audioonsetsmarker->output("signal").set(output_signal); + _audioonsetsmarker->compute(); + val outputAudioOnsetsMarker(val::object()); + outputAudioOnsetsMarker.set("signal", output_signal); + return outputAudioOnsetsMarker; +} +void AudioOnsetsMarker::reset() { +_audioonsetsmarker->reset(); +} +// END AudioOnsetsMarker definitions + +// START AutoCorrelation definitions // check https://essentia.upf.edu/reference/std_AutoCorrelation.html -val EssentiaJS::AutoCorrelation(std::vector& input_array, const float frequencyDomainCompression, const bool generalized, const std::string& normalization) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoAutoCorrelation = factory.create("AutoCorrelation", "frequencyDomainCompression", frequencyDomainCompression, "generalized", generalized, "normalization", normalization); - algoAutoCorrelation->input("array").set(input_array); - std::vector output_autoCorrelation; - algoAutoCorrelation->output("autoCorrelation").set(output_autoCorrelation); - algoAutoCorrelation->compute(); - val outputAutoCorrelation(val::object()); - outputAutoCorrelation.set("autoCorrelation", output_autoCorrelation); - delete algoAutoCorrelation; - return outputAutoCorrelation; -} - +AutoCorrelation::AutoCorrelation(const float frequencyDomainCompression, const bool generalized, const std::string& normalization) { + configure(frequencyDomainCompression, generalized, normalization); +} +AutoCorrelation::~AutoCorrelation() { + delete _autocorrelation; +} +void AutoCorrelation::configure(const float frequencyDomainCompression, const bool generalized, const std::string& normalization) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _autocorrelation = factory.create("AutoCorrelation", "frequencyDomainCompression", frequencyDomainCompression, "generalized", generalized, "normalization", normalization); +} +val AutoCorrelation::compute(std::vector& input_array) { + _autocorrelation->input("array").set(input_array); + std::vector output_autoCorrelation; + _autocorrelation->output("autoCorrelation").set(output_autoCorrelation); + _autocorrelation->compute(); + val outputAutoCorrelation(val::object()); + outputAutoCorrelation.set("autoCorrelation", output_autoCorrelation); + return outputAutoCorrelation; +} +void AutoCorrelation::reset() { +_autocorrelation->reset(); +} +// END AutoCorrelation definitions + +// START BFCC definitions // check https://essentia.upf.edu/reference/std_BFCC.html -val EssentiaJS::BFCC(std::vector& input_spectrum, const int dctType, const float highFrequencyBound, const int inputSize, const int liftering, const std::string& logType, const float lowFrequencyBound, const std::string& normalize, const int numberBands, const int numberCoefficients, const float sampleRate, const std::string& type, const std::string& weighting) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoBFCC = factory.create("BFCC", "dctType", dctType, "highFrequencyBound", highFrequencyBound, "inputSize", inputSize, "liftering", liftering, "logType", logType, "lowFrequencyBound", lowFrequencyBound, "normalize", normalize, "numberBands", numberBands, "numberCoefficients", numberCoefficients, "sampleRate", sampleRate, "type", type, "weighting", weighting); - algoBFCC->input("spectrum").set(input_spectrum); - std::vector output_bands; - std::vector output_bfcc; - algoBFCC->output("bands").set(output_bands); - algoBFCC->output("bfcc").set(output_bfcc); - algoBFCC->compute(); - val outputBFCC(val::object()); - outputBFCC.set("bands", output_bands); - outputBFCC.set("bfcc", output_bfcc); - delete algoBFCC; - return outputBFCC; -} - +BFCC::BFCC(const int dctType, const float highFrequencyBound, const int inputSize, const int liftering, const std::string& logType, const float lowFrequencyBound, const std::string& normalize, const int numberBands, const int numberCoefficients, const float sampleRate, const std::string& type, const std::string& weighting) { + configure(dctType, highFrequencyBound, inputSize, liftering, logType, lowFrequencyBound, normalize, numberBands, numberCoefficients, sampleRate, type, weighting); +} +BFCC::~BFCC() { + delete _bfcc; +} +void BFCC::configure(const int dctType, const float highFrequencyBound, const int inputSize, const int liftering, const std::string& logType, const float lowFrequencyBound, const std::string& normalize, const int numberBands, const int numberCoefficients, const float sampleRate, const std::string& type, const std::string& weighting) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _bfcc = factory.create("BFCC", "dctType", dctType, "highFrequencyBound", highFrequencyBound, "inputSize", inputSize, "liftering", liftering, "logType", logType, "lowFrequencyBound", lowFrequencyBound, "normalize", normalize, "numberBands", numberBands, "numberCoefficients", numberCoefficients, "sampleRate", sampleRate, "type", type, "weighting", weighting); +} +val BFCC::compute(std::vector& input_spectrum) { + _bfcc->input("spectrum").set(input_spectrum); + std::vector output_bands; + std::vector output_bfcc; + _bfcc->output("bands").set(output_bands); + _bfcc->output("bfcc").set(output_bfcc); + _bfcc->compute(); + val outputBFCC(val::object()); + outputBFCC.set("bands", output_bands); + outputBFCC.set("bfcc", output_bfcc); + return outputBFCC; +} +void BFCC::reset() { +_bfcc->reset(); +} +// END BFCC definitions + +// START BPF definitions // check https://essentia.upf.edu/reference/std_BPF.html -val EssentiaJS::BPF(float input_x, const std::vector& xPoints, const std::vector& yPoints) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoBPF = factory.create("BPF", "xPoints", xPoints, "yPoints", yPoints); - algoBPF->input("x").set(input_x); - float output_y; - algoBPF->output("y").set(output_y); - algoBPF->compute(); - val outputBPF(val::object()); - outputBPF.set("y", output_y); - delete algoBPF; - return outputBPF; -} - +BPF::BPF(const std::vector& xPoints, const std::vector& yPoints) { + configure(xPoints, yPoints); +} +BPF::~BPF() { + delete _bpf; +} +void BPF::configure(const std::vector& xPoints, const std::vector& yPoints) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _bpf = factory.create("BPF", "xPoints", xPoints, "yPoints", yPoints); +} +val BPF::compute(float input_x) { + _bpf->input("x").set(input_x); + float output_y; + _bpf->output("y").set(output_y); + _bpf->compute(); + val outputBPF(val::object()); + outputBPF.set("y", output_y); + return outputBPF; +} +void BPF::reset() { +_bpf->reset(); +} +// END BPF definitions + +// START BandPass definitions // check https://essentia.upf.edu/reference/std_BandPass.html -val EssentiaJS::BandPass(std::vector& input_signal, const float bandwidth, const float cutoffFrequency, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoBandPass = factory.create("BandPass", "bandwidth", bandwidth, "cutoffFrequency", cutoffFrequency, "sampleRate", sampleRate); - algoBandPass->input("signal").set(input_signal); - std::vector output_signal; - algoBandPass->output("signal").set(output_signal); - algoBandPass->compute(); - val outputBandPass(val::object()); - outputBandPass.set("signal", output_signal); - delete algoBandPass; - return outputBandPass; -} - +BandPass::BandPass(const float bandwidth, const float cutoffFrequency, const float sampleRate) { + configure(bandwidth, cutoffFrequency, sampleRate); +} +BandPass::~BandPass() { + delete _bandpass; +} +void BandPass::configure(const float bandwidth, const float cutoffFrequency, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _bandpass = factory.create("BandPass", "bandwidth", bandwidth, "cutoffFrequency", cutoffFrequency, "sampleRate", sampleRate); +} +val BandPass::compute(std::vector& input_signal) { + _bandpass->input("signal").set(input_signal); + std::vector output_signal; + _bandpass->output("signal").set(output_signal); + _bandpass->compute(); + val outputBandPass(val::object()); + outputBandPass.set("signal", output_signal); + return outputBandPass; +} +void BandPass::reset() { +_bandpass->reset(); +} +// END BandPass definitions + +// START BandReject definitions // check https://essentia.upf.edu/reference/std_BandReject.html -val EssentiaJS::BandReject(std::vector& input_signal, const float bandwidth, const float cutoffFrequency, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoBandReject = factory.create("BandReject", "bandwidth", bandwidth, "cutoffFrequency", cutoffFrequency, "sampleRate", sampleRate); - algoBandReject->input("signal").set(input_signal); - std::vector output_signal; - algoBandReject->output("signal").set(output_signal); - algoBandReject->compute(); - val outputBandReject(val::object()); - outputBandReject.set("signal", output_signal); - delete algoBandReject; - return outputBandReject; -} - +BandReject::BandReject(const float bandwidth, const float cutoffFrequency, const float sampleRate) { + configure(bandwidth, cutoffFrequency, sampleRate); +} +BandReject::~BandReject() { + delete _bandreject; +} +void BandReject::configure(const float bandwidth, const float cutoffFrequency, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _bandreject = factory.create("BandReject", "bandwidth", bandwidth, "cutoffFrequency", cutoffFrequency, "sampleRate", sampleRate); +} +val BandReject::compute(std::vector& input_signal) { + _bandreject->input("signal").set(input_signal); + std::vector output_signal; + _bandreject->output("signal").set(output_signal); + _bandreject->compute(); + val outputBandReject(val::object()); + outputBandReject.set("signal", output_signal); + return outputBandReject; +} +void BandReject::reset() { +_bandreject->reset(); +} +// END BandReject definitions + +// START BarkBands definitions // check https://essentia.upf.edu/reference/std_BarkBands.html -val EssentiaJS::BarkBands(std::vector& input_spectrum, const int numberBands, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoBarkBands = factory.create("BarkBands", "numberBands", numberBands, "sampleRate", sampleRate); - algoBarkBands->input("spectrum").set(input_spectrum); - std::vector output_bands; - algoBarkBands->output("bands").set(output_bands); - algoBarkBands->compute(); - val outputBarkBands(val::object()); - outputBarkBands.set("bands", output_bands); - delete algoBarkBands; - return outputBarkBands; -} - +BarkBands::BarkBands(const int numberBands, const float sampleRate) { + configure(numberBands, sampleRate); +} +BarkBands::~BarkBands() { + delete _barkbands; +} +void BarkBands::configure(const int numberBands, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _barkbands = factory.create("BarkBands", "numberBands", numberBands, "sampleRate", sampleRate); +} +val BarkBands::compute(std::vector& input_spectrum) { + _barkbands->input("spectrum").set(input_spectrum); + std::vector output_bands; + _barkbands->output("bands").set(output_bands); + _barkbands->compute(); + val outputBarkBands(val::object()); + outputBarkBands.set("bands", output_bands); + return outputBarkBands; +} +void BarkBands::reset() { +_barkbands->reset(); +} +// END BarkBands definitions + +// START BeatTrackerDegara definitions // check https://essentia.upf.edu/reference/std_BeatTrackerDegara.html -val EssentiaJS::BeatTrackerDegara(std::vector& input_signal, const int maxTempo, const int minTempo) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoBeatTrackerDegara = factory.create("BeatTrackerDegara", "maxTempo", maxTempo, "minTempo", minTempo); - algoBeatTrackerDegara->input("signal").set(input_signal); - std::vector output_ticks; - algoBeatTrackerDegara->output("ticks").set(output_ticks); - algoBeatTrackerDegara->compute(); - val outputBeatTrackerDegara(val::object()); - outputBeatTrackerDegara.set("ticks", output_ticks); - delete algoBeatTrackerDegara; - return outputBeatTrackerDegara; -} - +BeatTrackerDegara::BeatTrackerDegara(const int maxTempo, const int minTempo) { + configure(maxTempo, minTempo); +} +BeatTrackerDegara::~BeatTrackerDegara() { + delete _beattrackerdegara; +} +void BeatTrackerDegara::configure(const int maxTempo, const int minTempo) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _beattrackerdegara = factory.create("BeatTrackerDegara", "maxTempo", maxTempo, "minTempo", minTempo); +} +val BeatTrackerDegara::compute(std::vector& input_signal) { + _beattrackerdegara->input("signal").set(input_signal); + std::vector output_ticks; + _beattrackerdegara->output("ticks").set(output_ticks); + _beattrackerdegara->compute(); + val outputBeatTrackerDegara(val::object()); + outputBeatTrackerDegara.set("ticks", output_ticks); + return outputBeatTrackerDegara; +} +void BeatTrackerDegara::reset() { +_beattrackerdegara->reset(); +} +// END BeatTrackerDegara definitions + +// START BeatTrackerMultiFeature definitions // check https://essentia.upf.edu/reference/std_BeatTrackerMultiFeature.html -val EssentiaJS::BeatTrackerMultiFeature(std::vector& input_signal, const int maxTempo, const int minTempo) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoBeatTrackerMultiFeature = factory.create("BeatTrackerMultiFeature", "maxTempo", maxTempo, "minTempo", minTempo); - algoBeatTrackerMultiFeature->input("signal").set(input_signal); - std::vector output_ticks; - float output_confidence; - algoBeatTrackerMultiFeature->output("ticks").set(output_ticks); - algoBeatTrackerMultiFeature->output("confidence").set(output_confidence); - algoBeatTrackerMultiFeature->compute(); - val outputBeatTrackerMultiFeature(val::object()); - outputBeatTrackerMultiFeature.set("ticks", output_ticks); - outputBeatTrackerMultiFeature.set("confidence", output_confidence); - delete algoBeatTrackerMultiFeature; - return outputBeatTrackerMultiFeature; -} - +BeatTrackerMultiFeature::BeatTrackerMultiFeature(const int maxTempo, const int minTempo) { + configure(maxTempo, minTempo); +} +BeatTrackerMultiFeature::~BeatTrackerMultiFeature() { + delete _beattrackermultifeature; +} +void BeatTrackerMultiFeature::configure(const int maxTempo, const int minTempo) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _beattrackermultifeature = factory.create("BeatTrackerMultiFeature", "maxTempo", maxTempo, "minTempo", minTempo); +} +val BeatTrackerMultiFeature::compute(std::vector& input_signal) { + _beattrackermultifeature->input("signal").set(input_signal); + std::vector output_ticks; + float output_confidence; + _beattrackermultifeature->output("ticks").set(output_ticks); + _beattrackermultifeature->output("confidence").set(output_confidence); + _beattrackermultifeature->compute(); + val outputBeatTrackerMultiFeature(val::object()); + outputBeatTrackerMultiFeature.set("ticks", output_ticks); + outputBeatTrackerMultiFeature.set("confidence", output_confidence); + return outputBeatTrackerMultiFeature; +} +void BeatTrackerMultiFeature::reset() { +_beattrackermultifeature->reset(); +} +// END BeatTrackerMultiFeature definitions + +// START Beatogram definitions // check https://essentia.upf.edu/reference/std_Beatogram.html -val EssentiaJS::Beatogram(std::vector& input_loudness, std::vector >& input_loudnessBandRatio, const int size) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoBeatogram = factory.create("Beatogram", "size", size); - algoBeatogram->input("loudness").set(input_loudness); - algoBeatogram->input("loudnessBandRatio").set(input_loudnessBandRatio); - std::vector > output_beatogram; - algoBeatogram->output("beatogram").set(output_beatogram); - algoBeatogram->compute(); - val outputBeatogram(val::object()); - outputBeatogram.set("beatogram", output_beatogram); - delete algoBeatogram; - return outputBeatogram; -} - +Beatogram::Beatogram(const int size) { + configure(size); +} +Beatogram::~Beatogram() { + delete _beatogram; +} +void Beatogram::configure(const int size) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _beatogram = factory.create("Beatogram", "size", size); +} +val Beatogram::compute(std::vector& input_loudness, std::vector >& input_loudnessBandRatio) { + _beatogram->input("loudness").set(input_loudness); + _beatogram->input("loudnessBandRatio").set(input_loudnessBandRatio); + std::vector > output_beatogram; + _beatogram->output("beatogram").set(output_beatogram); + _beatogram->compute(); + val outputBeatogram(val::object()); + outputBeatogram.set("beatogram", output_beatogram); + return outputBeatogram; +} +void Beatogram::reset() { +_beatogram->reset(); +} +// END Beatogram definitions + +// START BeatsLoudness definitions // check https://essentia.upf.edu/reference/std_BeatsLoudness.html -val EssentiaJS::BeatsLoudness(std::vector& input_signal, const float beatDuration, const float beatWindowDuration, const std::vector& beats, const std::vector& frequencyBands, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoBeatsLoudness = factory.create("BeatsLoudness", "beatDuration", beatDuration, "beatWindowDuration", beatWindowDuration, "beats", beats, "frequencyBands", frequencyBands, "sampleRate", sampleRate); - algoBeatsLoudness->input("signal").set(input_signal); - std::vector output_loudness; - std::vector > output_loudnessBandRatio; - algoBeatsLoudness->output("loudness").set(output_loudness); - algoBeatsLoudness->output("loudnessBandRatio").set(output_loudnessBandRatio); - algoBeatsLoudness->compute(); - val outputBeatsLoudness(val::object()); - outputBeatsLoudness.set("loudness", output_loudness); - outputBeatsLoudness.set("loudnessBandRatio", output_loudnessBandRatio); - delete algoBeatsLoudness; - return outputBeatsLoudness; -} - +BeatsLoudness::BeatsLoudness(const float beatDuration, const float beatWindowDuration, const std::vector& beats, const std::vector& frequencyBands, const float sampleRate) { + configure(beatDuration, beatWindowDuration, beats, frequencyBands, sampleRate); +} +BeatsLoudness::~BeatsLoudness() { + delete _beatsloudness; +} +void BeatsLoudness::configure(const float beatDuration, const float beatWindowDuration, const std::vector& beats, const std::vector& frequencyBands, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _beatsloudness = factory.create("BeatsLoudness", "beatDuration", beatDuration, "beatWindowDuration", beatWindowDuration, "beats", beats, "frequencyBands", frequencyBands, "sampleRate", sampleRate); +} +val BeatsLoudness::compute(std::vector& input_signal) { + _beatsloudness->input("signal").set(input_signal); + std::vector output_loudness; + std::vector > output_loudnessBandRatio; + _beatsloudness->output("loudness").set(output_loudness); + _beatsloudness->output("loudnessBandRatio").set(output_loudnessBandRatio); + _beatsloudness->compute(); + val outputBeatsLoudness(val::object()); + outputBeatsLoudness.set("loudness", output_loudness); + outputBeatsLoudness.set("loudnessBandRatio", output_loudnessBandRatio); + return outputBeatsLoudness; +} +void BeatsLoudness::reset() { +_beatsloudness->reset(); +} +// END BeatsLoudness definitions + +// START BinaryOperator definitions // check https://essentia.upf.edu/reference/std_BinaryOperator.html -val EssentiaJS::BinaryOperator(std::vector& input_array1, std::vector& input_array2, const std::string& type) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoBinaryOperator = factory.create("BinaryOperator", "type", type); - algoBinaryOperator->input("array1").set(input_array1); - algoBinaryOperator->input("array2").set(input_array2); - std::vector output_array; - algoBinaryOperator->output("array").set(output_array); - algoBinaryOperator->compute(); - val outputBinaryOperator(val::object()); - outputBinaryOperator.set("array", output_array); - delete algoBinaryOperator; - return outputBinaryOperator; -} - +BinaryOperator::BinaryOperator(const std::string& type) { + configure(type); +} +BinaryOperator::~BinaryOperator() { + delete _binaryoperator; +} +void BinaryOperator::configure(const std::string& type) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _binaryoperator = factory.create("BinaryOperator", "type", type); +} +val BinaryOperator::compute(std::vector& input_array1, std::vector& input_array2) { + _binaryoperator->input("array1").set(input_array1); + _binaryoperator->input("array2").set(input_array2); + std::vector output_array; + _binaryoperator->output("array").set(output_array); + _binaryoperator->compute(); + val outputBinaryOperator(val::object()); + outputBinaryOperator.set("array", output_array); + return outputBinaryOperator; +} +void BinaryOperator::reset() { +_binaryoperator->reset(); +} +// END BinaryOperator definitions + +// START BinaryOperatorStream definitions // check https://essentia.upf.edu/reference/std_BinaryOperatorStream.html -val EssentiaJS::BinaryOperatorStream(std::vector& input_array1, std::vector& input_array2, const std::string& type) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoBinaryOperatorStream = factory.create("BinaryOperatorStream", "type", type); - algoBinaryOperatorStream->input("array1").set(input_array1); - algoBinaryOperatorStream->input("array2").set(input_array2); - std::vector output_array; - algoBinaryOperatorStream->output("array").set(output_array); - algoBinaryOperatorStream->compute(); - val outputBinaryOperatorStream(val::object()); - outputBinaryOperatorStream.set("array", output_array); - delete algoBinaryOperatorStream; - return outputBinaryOperatorStream; -} - +BinaryOperatorStream::BinaryOperatorStream(const std::string& type) { + configure(type); +} +BinaryOperatorStream::~BinaryOperatorStream() { + delete _binaryoperatorstream; +} +void BinaryOperatorStream::configure(const std::string& type) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _binaryoperatorstream = factory.create("BinaryOperatorStream", "type", type); +} +val BinaryOperatorStream::compute(std::vector& input_array1, std::vector& input_array2) { + _binaryoperatorstream->input("array1").set(input_array1); + _binaryoperatorstream->input("array2").set(input_array2); + std::vector output_array; + _binaryoperatorstream->output("array").set(output_array); + _binaryoperatorstream->compute(); + val outputBinaryOperatorStream(val::object()); + outputBinaryOperatorStream.set("array", output_array); + return outputBinaryOperatorStream; +} +void BinaryOperatorStream::reset() { +_binaryoperatorstream->reset(); +} +// END BinaryOperatorStream definitions + +// START BpmHistogramDescriptors definitions // check https://essentia.upf.edu/reference/std_BpmHistogramDescriptors.html -val EssentiaJS::BpmHistogramDescriptors(std::vector& input_bpmIntervals) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoBpmHistogramDescriptors = factory.create("BpmHistogramDescriptors"); - algoBpmHistogramDescriptors->input("bpmIntervals").set(input_bpmIntervals); - float output_firstPeakBPM; - float output_firstPeakWeight; - float output_firstPeakSpread; - float output_secondPeakBPM; - float output_secondPeakWeight; - float output_secondPeakSpread; - std::vector output_histogram; - algoBpmHistogramDescriptors->output("firstPeakBPM").set(output_firstPeakBPM); - algoBpmHistogramDescriptors->output("firstPeakWeight").set(output_firstPeakWeight); - algoBpmHistogramDescriptors->output("firstPeakSpread").set(output_firstPeakSpread); - algoBpmHistogramDescriptors->output("secondPeakBPM").set(output_secondPeakBPM); - algoBpmHistogramDescriptors->output("secondPeakWeight").set(output_secondPeakWeight); - algoBpmHistogramDescriptors->output("secondPeakSpread").set(output_secondPeakSpread); - algoBpmHistogramDescriptors->output("histogram").set(output_histogram); - algoBpmHistogramDescriptors->compute(); - val outputBpmHistogramDescriptors(val::object()); - outputBpmHistogramDescriptors.set("firstPeakBPM", output_firstPeakBPM); - outputBpmHistogramDescriptors.set("firstPeakWeight", output_firstPeakWeight); - outputBpmHistogramDescriptors.set("firstPeakSpread", output_firstPeakSpread); - outputBpmHistogramDescriptors.set("secondPeakBPM", output_secondPeakBPM); - outputBpmHistogramDescriptors.set("secondPeakWeight", output_secondPeakWeight); - outputBpmHistogramDescriptors.set("secondPeakSpread", output_secondPeakSpread); - outputBpmHistogramDescriptors.set("histogram", output_histogram); - delete algoBpmHistogramDescriptors; - return outputBpmHistogramDescriptors; -} - +BpmHistogramDescriptors::BpmHistogramDescriptors() { + configure(); +} +BpmHistogramDescriptors::~BpmHistogramDescriptors() { + delete _bpmhistogramdescriptors; +} +void BpmHistogramDescriptors::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _bpmhistogramdescriptors = factory.create("BpmHistogramDescriptors"); +} +val BpmHistogramDescriptors::compute(std::vector& input_bpmIntervals) { + _bpmhistogramdescriptors->input("bpmIntervals").set(input_bpmIntervals); + float output_firstPeakBPM; + float output_firstPeakWeight; + float output_firstPeakSpread; + float output_secondPeakBPM; + float output_secondPeakWeight; + float output_secondPeakSpread; + std::vector output_histogram; + _bpmhistogramdescriptors->output("firstPeakBPM").set(output_firstPeakBPM); + _bpmhistogramdescriptors->output("firstPeakWeight").set(output_firstPeakWeight); + _bpmhistogramdescriptors->output("firstPeakSpread").set(output_firstPeakSpread); + _bpmhistogramdescriptors->output("secondPeakBPM").set(output_secondPeakBPM); + _bpmhistogramdescriptors->output("secondPeakWeight").set(output_secondPeakWeight); + _bpmhistogramdescriptors->output("secondPeakSpread").set(output_secondPeakSpread); + _bpmhistogramdescriptors->output("histogram").set(output_histogram); + _bpmhistogramdescriptors->compute(); + val outputBpmHistogramDescriptors(val::object()); + outputBpmHistogramDescriptors.set("firstPeakBPM", output_firstPeakBPM); + outputBpmHistogramDescriptors.set("firstPeakWeight", output_firstPeakWeight); + outputBpmHistogramDescriptors.set("firstPeakSpread", output_firstPeakSpread); + outputBpmHistogramDescriptors.set("secondPeakBPM", output_secondPeakBPM); + outputBpmHistogramDescriptors.set("secondPeakWeight", output_secondPeakWeight); + outputBpmHistogramDescriptors.set("secondPeakSpread", output_secondPeakSpread); + outputBpmHistogramDescriptors.set("histogram", output_histogram); + return outputBpmHistogramDescriptors; +} +void BpmHistogramDescriptors::reset() { +_bpmhistogramdescriptors->reset(); +} +// END BpmHistogramDescriptors definitions + +// START BpmRubato definitions // check https://essentia.upf.edu/reference/std_BpmRubato.html -val EssentiaJS::BpmRubato(std::vector& input_beats, const float longRegionsPruningTime, const float shortRegionsMergingTime, const float tolerance) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoBpmRubato = factory.create("BpmRubato", "longRegionsPruningTime", longRegionsPruningTime, "shortRegionsMergingTime", shortRegionsMergingTime, "tolerance", tolerance); - algoBpmRubato->input("beats").set(input_beats); - std::vector output_rubatoStart; - std::vector output_rubatoStop; - int output_rubatoNumber; - algoBpmRubato->output("rubatoStart").set(output_rubatoStart); - algoBpmRubato->output("rubatoStop").set(output_rubatoStop); - algoBpmRubato->output("rubatoNumber").set(output_rubatoNumber); - algoBpmRubato->compute(); - val outputBpmRubato(val::object()); - outputBpmRubato.set("rubatoStart", output_rubatoStart); - outputBpmRubato.set("rubatoStop", output_rubatoStop); - outputBpmRubato.set("rubatoNumber", output_rubatoNumber); - delete algoBpmRubato; - return outputBpmRubato; -} - +BpmRubato::BpmRubato(const float longRegionsPruningTime, const float shortRegionsMergingTime, const float tolerance) { + configure(longRegionsPruningTime, shortRegionsMergingTime, tolerance); +} +BpmRubato::~BpmRubato() { + delete _bpmrubato; +} +void BpmRubato::configure(const float longRegionsPruningTime, const float shortRegionsMergingTime, const float tolerance) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _bpmrubato = factory.create("BpmRubato", "longRegionsPruningTime", longRegionsPruningTime, "shortRegionsMergingTime", shortRegionsMergingTime, "tolerance", tolerance); +} +val BpmRubato::compute(std::vector& input_beats) { + _bpmrubato->input("beats").set(input_beats); + std::vector output_rubatoStart; + std::vector output_rubatoStop; + int output_rubatoNumber; + _bpmrubato->output("rubatoStart").set(output_rubatoStart); + _bpmrubato->output("rubatoStop").set(output_rubatoStop); + _bpmrubato->output("rubatoNumber").set(output_rubatoNumber); + _bpmrubato->compute(); + val outputBpmRubato(val::object()); + outputBpmRubato.set("rubatoStart", output_rubatoStart); + outputBpmRubato.set("rubatoStop", output_rubatoStop); + outputBpmRubato.set("rubatoNumber", output_rubatoNumber); + return outputBpmRubato; +} +void BpmRubato::reset() { +_bpmrubato->reset(); +} +// END BpmRubato definitions + +// START CentralMoments definitions // check https://essentia.upf.edu/reference/std_CentralMoments.html -val EssentiaJS::CentralMoments(std::vector& input_array, const std::string& mode, const float range) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoCentralMoments = factory.create("CentralMoments", "mode", mode, "range", range); - algoCentralMoments->input("array").set(input_array); - std::vector output_centralMoments; - algoCentralMoments->output("centralMoments").set(output_centralMoments); - algoCentralMoments->compute(); - val outputCentralMoments(val::object()); - outputCentralMoments.set("centralMoments", output_centralMoments); - delete algoCentralMoments; - return outputCentralMoments; -} - +CentralMoments::CentralMoments(const std::string& mode, const float range) { + configure(mode, range); +} +CentralMoments::~CentralMoments() { + delete _centralmoments; +} +void CentralMoments::configure(const std::string& mode, const float range) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _centralmoments = factory.create("CentralMoments", "mode", mode, "range", range); +} +val CentralMoments::compute(std::vector& input_array) { + _centralmoments->input("array").set(input_array); + std::vector output_centralMoments; + _centralmoments->output("centralMoments").set(output_centralMoments); + _centralmoments->compute(); + val outputCentralMoments(val::object()); + outputCentralMoments.set("centralMoments", output_centralMoments); + return outputCentralMoments; +} +void CentralMoments::reset() { +_centralmoments->reset(); +} +// END CentralMoments definitions + +// START Centroid definitions // check https://essentia.upf.edu/reference/std_Centroid.html -val EssentiaJS::Centroid(std::vector& input_array, const float range) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoCentroid = factory.create("Centroid", "range", range); - algoCentroid->input("array").set(input_array); - float output_centroid; - algoCentroid->output("centroid").set(output_centroid); - algoCentroid->compute(); - val outputCentroid(val::object()); - outputCentroid.set("centroid", output_centroid); - delete algoCentroid; - return outputCentroid; -} - +Centroid::Centroid(const float range) { + configure(range); +} +Centroid::~Centroid() { + delete _centroid; +} +void Centroid::configure(const float range) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _centroid = factory.create("Centroid", "range", range); +} +val Centroid::compute(std::vector& input_array) { + _centroid->input("array").set(input_array); + float output_centroid; + _centroid->output("centroid").set(output_centroid); + _centroid->compute(); + val outputCentroid(val::object()); + outputCentroid.set("centroid", output_centroid); + return outputCentroid; +} +void Centroid::reset() { +_centroid->reset(); +} +// END Centroid definitions + +// START ChordsDescriptors definitions // check https://essentia.upf.edu/reference/std_ChordsDescriptors.html -val EssentiaJS::ChordsDescriptors(std::vector input_chords, std::string input_key, std::string input_scale) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoChordsDescriptors = factory.create("ChordsDescriptors"); - algoChordsDescriptors->input("chords").set(input_chords); - algoChordsDescriptors->input("key").set(input_key); - algoChordsDescriptors->input("scale").set(input_scale); - std::vector output_chordsHistogram; - float output_chordsNumberRate; - float output_chordsChangesRate; - std::string output_chordsKey; - std::string output_chordsScale; - algoChordsDescriptors->output("chordsHistogram").set(output_chordsHistogram); - algoChordsDescriptors->output("chordsNumberRate").set(output_chordsNumberRate); - algoChordsDescriptors->output("chordsChangesRate").set(output_chordsChangesRate); - algoChordsDescriptors->output("chordsKey").set(output_chordsKey); - algoChordsDescriptors->output("chordsScale").set(output_chordsScale); - algoChordsDescriptors->compute(); - val outputChordsDescriptors(val::object()); - outputChordsDescriptors.set("chordsHistogram", output_chordsHistogram); - outputChordsDescriptors.set("chordsNumberRate", output_chordsNumberRate); - outputChordsDescriptors.set("chordsChangesRate", output_chordsChangesRate); - outputChordsDescriptors.set("chordsKey", output_chordsKey); - outputChordsDescriptors.set("chordsScale", output_chordsScale); - delete algoChordsDescriptors; - return outputChordsDescriptors; -} - +ChordsDescriptors::ChordsDescriptors() { + configure(); +} +ChordsDescriptors::~ChordsDescriptors() { + delete _chordsdescriptors; +} +void ChordsDescriptors::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _chordsdescriptors = factory.create("ChordsDescriptors"); +} +val ChordsDescriptors::compute(std::vector input_chords, std::string input_key, std::string input_scale) { + _chordsdescriptors->input("chords").set(input_chords); + _chordsdescriptors->input("key").set(input_key); + _chordsdescriptors->input("scale").set(input_scale); + std::vector output_chordsHistogram; + float output_chordsNumberRate; + float output_chordsChangesRate; + std::string output_chordsKey; + std::string output_chordsScale; + _chordsdescriptors->output("chordsHistogram").set(output_chordsHistogram); + _chordsdescriptors->output("chordsNumberRate").set(output_chordsNumberRate); + _chordsdescriptors->output("chordsChangesRate").set(output_chordsChangesRate); + _chordsdescriptors->output("chordsKey").set(output_chordsKey); + _chordsdescriptors->output("chordsScale").set(output_chordsScale); + _chordsdescriptors->compute(); + val outputChordsDescriptors(val::object()); + outputChordsDescriptors.set("chordsHistogram", output_chordsHistogram); + outputChordsDescriptors.set("chordsNumberRate", output_chordsNumberRate); + outputChordsDescriptors.set("chordsChangesRate", output_chordsChangesRate); + outputChordsDescriptors.set("chordsKey", output_chordsKey); + outputChordsDescriptors.set("chordsScale", output_chordsScale); + return outputChordsDescriptors; +} +void ChordsDescriptors::reset() { +_chordsdescriptors->reset(); +} +// END ChordsDescriptors definitions + +// START ChordsDetection definitions // check https://essentia.upf.edu/reference/std_ChordsDetection.html -val EssentiaJS::ChordsDetection(std::vector >& input_pcp, const int hopSize, const float sampleRate, const float windowSize) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoChordsDetection = factory.create("ChordsDetection", "hopSize", hopSize, "sampleRate", sampleRate, "windowSize", windowSize); - algoChordsDetection->input("pcp").set(input_pcp); - std::vector output_chords; - std::vector output_strength; - algoChordsDetection->output("chords").set(output_chords); - algoChordsDetection->output("strength").set(output_strength); - algoChordsDetection->compute(); - val outputChordsDetection(val::object()); - outputChordsDetection.set("chords", output_chords); - outputChordsDetection.set("strength", output_strength); - delete algoChordsDetection; - return outputChordsDetection; -} - +ChordsDetection::ChordsDetection(const int hopSize, const float sampleRate, const float windowSize) { + configure(hopSize, sampleRate, windowSize); +} +ChordsDetection::~ChordsDetection() { + delete _chordsdetection; +} +void ChordsDetection::configure(const int hopSize, const float sampleRate, const float windowSize) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _chordsdetection = factory.create("ChordsDetection", "hopSize", hopSize, "sampleRate", sampleRate, "windowSize", windowSize); +} +val ChordsDetection::compute(std::vector >& input_pcp) { + _chordsdetection->input("pcp").set(input_pcp); + std::vector output_chords; + std::vector output_strength; + _chordsdetection->output("chords").set(output_chords); + _chordsdetection->output("strength").set(output_strength); + _chordsdetection->compute(); + val outputChordsDetection(val::object()); + outputChordsDetection.set("chords", output_chords); + outputChordsDetection.set("strength", output_strength); + return outputChordsDetection; +} +void ChordsDetection::reset() { +_chordsdetection->reset(); +} +// END ChordsDetection definitions + +// START ChordsDetectionBeats definitions // check https://essentia.upf.edu/reference/std_ChordsDetectionBeats.html -val EssentiaJS::ChordsDetectionBeats(std::vector >& input_pcp, std::vector& input_ticks, const std::string& chromaPick, const int hopSize, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoChordsDetectionBeats = factory.create("ChordsDetectionBeats", "chromaPick", chromaPick, "hopSize", hopSize, "sampleRate", sampleRate); - algoChordsDetectionBeats->input("pcp").set(input_pcp); - algoChordsDetectionBeats->input("ticks").set(input_ticks); - std::vector output_chords; - std::vector output_strength; - algoChordsDetectionBeats->output("chords").set(output_chords); - algoChordsDetectionBeats->output("strength").set(output_strength); - algoChordsDetectionBeats->compute(); - val outputChordsDetectionBeats(val::object()); - outputChordsDetectionBeats.set("chords", output_chords); - outputChordsDetectionBeats.set("strength", output_strength); - delete algoChordsDetectionBeats; - return outputChordsDetectionBeats; -} - +ChordsDetectionBeats::ChordsDetectionBeats(const std::string& chromaPick, const int hopSize, const float sampleRate) { + configure(chromaPick, hopSize, sampleRate); +} +ChordsDetectionBeats::~ChordsDetectionBeats() { + delete _chordsdetectionbeats; +} +void ChordsDetectionBeats::configure(const std::string& chromaPick, const int hopSize, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _chordsdetectionbeats = factory.create("ChordsDetectionBeats", "chromaPick", chromaPick, "hopSize", hopSize, "sampleRate", sampleRate); +} +val ChordsDetectionBeats::compute(std::vector >& input_pcp, std::vector& input_ticks) { + _chordsdetectionbeats->input("pcp").set(input_pcp); + _chordsdetectionbeats->input("ticks").set(input_ticks); + std::vector output_chords; + std::vector output_strength; + _chordsdetectionbeats->output("chords").set(output_chords); + _chordsdetectionbeats->output("strength").set(output_strength); + _chordsdetectionbeats->compute(); + val outputChordsDetectionBeats(val::object()); + outputChordsDetectionBeats.set("chords", output_chords); + outputChordsDetectionBeats.set("strength", output_strength); + return outputChordsDetectionBeats; +} +void ChordsDetectionBeats::reset() { +_chordsdetectionbeats->reset(); +} +// END ChordsDetectionBeats definitions + +// START ChromaCrossSimilarity definitions // check https://essentia.upf.edu/reference/std_ChromaCrossSimilarity.html -val EssentiaJS::ChromaCrossSimilarity(std::vector >& input_queryFeature, std::vector >& input_referenceFeature, const float binarizePercentile, const int frameStackSize, const int frameStackStride, const int noti, const bool oti, const bool otiBinary, const bool streaming) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoChromaCrossSimilarity = factory.create("ChromaCrossSimilarity", "binarizePercentile", binarizePercentile, "frameStackSize", frameStackSize, "frameStackStride", frameStackStride, "noti", noti, "oti", oti, "otiBinary", otiBinary, "streaming", streaming); - algoChromaCrossSimilarity->input("queryFeature").set(input_queryFeature); - algoChromaCrossSimilarity->input("referenceFeature").set(input_referenceFeature); - std::vector > output_csm; - algoChromaCrossSimilarity->output("csm").set(output_csm); - algoChromaCrossSimilarity->compute(); - val outputChromaCrossSimilarity(val::object()); - outputChromaCrossSimilarity.set("csm", output_csm); - delete algoChromaCrossSimilarity; - return outputChromaCrossSimilarity; -} - +ChromaCrossSimilarity::ChromaCrossSimilarity(const float binarizePercentile, const int frameStackSize, const int frameStackStride, const int noti, const bool oti, const bool otiBinary, const bool streaming) { + configure(binarizePercentile, frameStackSize, frameStackStride, noti, oti, otiBinary, streaming); +} +ChromaCrossSimilarity::~ChromaCrossSimilarity() { + delete _chromacrosssimilarity; +} +void ChromaCrossSimilarity::configure(const float binarizePercentile, const int frameStackSize, const int frameStackStride, const int noti, const bool oti, const bool otiBinary, const bool streaming) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _chromacrosssimilarity = factory.create("ChromaCrossSimilarity", "binarizePercentile", binarizePercentile, "frameStackSize", frameStackSize, "frameStackStride", frameStackStride, "noti", noti, "oti", oti, "otiBinary", otiBinary, "streaming", streaming); +} +val ChromaCrossSimilarity::compute(std::vector >& input_queryFeature, std::vector >& input_referenceFeature) { + _chromacrosssimilarity->input("queryFeature").set(input_queryFeature); + _chromacrosssimilarity->input("referenceFeature").set(input_referenceFeature); + std::vector > output_csm; + _chromacrosssimilarity->output("csm").set(output_csm); + _chromacrosssimilarity->compute(); + val outputChromaCrossSimilarity(val::object()); + outputChromaCrossSimilarity.set("csm", output_csm); + return outputChromaCrossSimilarity; +} +void ChromaCrossSimilarity::reset() { +_chromacrosssimilarity->reset(); +} +// END ChromaCrossSimilarity definitions + +// START Chromagram definitions // check https://essentia.upf.edu/reference/std_Chromagram.html -val EssentiaJS::Chromagram(std::vector& input_frame, const int binsPerOctave, const float minFrequency, const int minimumKernelSize, const std::string& normalizeType, const int numberBins, const float sampleRate, const float scale, const float threshold, const std::string& windowType, const bool zeroPhase) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoChromagram = factory.create("Chromagram", "binsPerOctave", binsPerOctave, "minFrequency", minFrequency, "minimumKernelSize", minimumKernelSize, "normalizeType", normalizeType, "numberBins", numberBins, "sampleRate", sampleRate, "scale", scale, "threshold", threshold, "windowType", windowType, "zeroPhase", zeroPhase); - algoChromagram->input("frame").set(input_frame); - std::vector output_chromagram; - algoChromagram->output("chromagram").set(output_chromagram); - algoChromagram->compute(); - val outputChromagram(val::object()); - outputChromagram.set("chromagram", output_chromagram); - delete algoChromagram; - return outputChromagram; -} - +Chromagram::Chromagram(const int binsPerOctave, const float minFrequency, const int minimumKernelSize, const std::string& normalizeType, const int numberBins, const float sampleRate, const float scale, const float threshold, const std::string& windowType, const bool zeroPhase) { + configure(binsPerOctave, minFrequency, minimumKernelSize, normalizeType, numberBins, sampleRate, scale, threshold, windowType, zeroPhase); +} +Chromagram::~Chromagram() { + delete _chromagram; +} +void Chromagram::configure(const int binsPerOctave, const float minFrequency, const int minimumKernelSize, const std::string& normalizeType, const int numberBins, const float sampleRate, const float scale, const float threshold, const std::string& windowType, const bool zeroPhase) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _chromagram = factory.create("Chromagram", "binsPerOctave", binsPerOctave, "minFrequency", minFrequency, "minimumKernelSize", minimumKernelSize, "normalizeType", normalizeType, "numberBins", numberBins, "sampleRate", sampleRate, "scale", scale, "threshold", threshold, "windowType", windowType, "zeroPhase", zeroPhase); +} +val Chromagram::compute(std::vector& input_frame) { + _chromagram->input("frame").set(input_frame); + std::vector output_chromagram; + _chromagram->output("chromagram").set(output_chromagram); + _chromagram->compute(); + val outputChromagram(val::object()); + outputChromagram.set("chromagram", output_chromagram); + return outputChromagram; +} +void Chromagram::reset() { +_chromagram->reset(); +} +// END Chromagram definitions + +// START ClickDetector definitions // check https://essentia.upf.edu/reference/std_ClickDetector.html -val EssentiaJS::ClickDetector(std::vector& input_frame, const float detectionThreshold, const int frameSize, const int hopSize, const int order, const int powerEstimationThreshold, const float sampleRate, const int silenceThreshold) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoClickDetector = factory.create("ClickDetector", "detectionThreshold", detectionThreshold, "frameSize", frameSize, "hopSize", hopSize, "order", order, "powerEstimationThreshold", powerEstimationThreshold, "sampleRate", sampleRate, "silenceThreshold", silenceThreshold); - algoClickDetector->input("frame").set(input_frame); - std::vector output_starts; - std::vector output_ends; - algoClickDetector->output("starts").set(output_starts); - algoClickDetector->output("ends").set(output_ends); - algoClickDetector->compute(); - val outputClickDetector(val::object()); - outputClickDetector.set("starts", output_starts); - outputClickDetector.set("ends", output_ends); - delete algoClickDetector; - return outputClickDetector; -} - +ClickDetector::ClickDetector(const float detectionThreshold, const int frameSize, const int hopSize, const int order, const int powerEstimationThreshold, const float sampleRate, const int silenceThreshold) { + configure(detectionThreshold, frameSize, hopSize, order, powerEstimationThreshold, sampleRate, silenceThreshold); +} +ClickDetector::~ClickDetector() { + delete _clickdetector; +} +void ClickDetector::configure(const float detectionThreshold, const int frameSize, const int hopSize, const int order, const int powerEstimationThreshold, const float sampleRate, const int silenceThreshold) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _clickdetector = factory.create("ClickDetector", "detectionThreshold", detectionThreshold, "frameSize", frameSize, "hopSize", hopSize, "order", order, "powerEstimationThreshold", powerEstimationThreshold, "sampleRate", sampleRate, "silenceThreshold", silenceThreshold); +} +val ClickDetector::compute(std::vector& input_frame) { + _clickdetector->input("frame").set(input_frame); + std::vector output_starts; + std::vector output_ends; + _clickdetector->output("starts").set(output_starts); + _clickdetector->output("ends").set(output_ends); + _clickdetector->compute(); + val outputClickDetector(val::object()); + outputClickDetector.set("starts", output_starts); + outputClickDetector.set("ends", output_ends); + return outputClickDetector; +} +void ClickDetector::reset() { +_clickdetector->reset(); +} +// END ClickDetector definitions + +// START Clipper definitions // check https://essentia.upf.edu/reference/std_Clipper.html -val EssentiaJS::Clipper(std::vector& input_signal, const float max, const float min) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoClipper = factory.create("Clipper", "max", max, "min", min); - algoClipper->input("signal").set(input_signal); - std::vector output_signal; - algoClipper->output("signal").set(output_signal); - algoClipper->compute(); - val outputClipper(val::object()); - outputClipper.set("signal", output_signal); - delete algoClipper; - return outputClipper; -} - +Clipper::Clipper(const float max, const float min) { + configure(max, min); +} +Clipper::~Clipper() { + delete _clipper; +} +void Clipper::configure(const float max, const float min) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _clipper = factory.create("Clipper", "max", max, "min", min); +} +val Clipper::compute(std::vector& input_signal) { + _clipper->input("signal").set(input_signal); + std::vector output_signal; + _clipper->output("signal").set(output_signal); + _clipper->compute(); + val outputClipper(val::object()); + outputClipper.set("signal", output_signal); + return outputClipper; +} +void Clipper::reset() { +_clipper->reset(); +} +// END Clipper definitions + +// START CoverSongSimilarity definitions // check https://essentia.upf.edu/reference/std_CoverSongSimilarity.html -val EssentiaJS::CoverSongSimilarity(std::vector >& input_inputArray, const std::string& alignmentType, const float disExtension, const float disOnset, const std::string& distanceType) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoCoverSongSimilarity = factory.create("CoverSongSimilarity", "alignmentType", alignmentType, "disExtension", disExtension, "disOnset", disOnset, "distanceType", distanceType); - algoCoverSongSimilarity->input("inputArray").set(input_inputArray); - std::vector > output_scoreMatrix; - float output_distance; - algoCoverSongSimilarity->output("scoreMatrix").set(output_scoreMatrix); - algoCoverSongSimilarity->output("distance").set(output_distance); - algoCoverSongSimilarity->compute(); - val outputCoverSongSimilarity(val::object()); - outputCoverSongSimilarity.set("scoreMatrix", output_scoreMatrix); - outputCoverSongSimilarity.set("distance", output_distance); - delete algoCoverSongSimilarity; - return outputCoverSongSimilarity; -} - +CoverSongSimilarity::CoverSongSimilarity(const std::string& alignmentType, const float disExtension, const float disOnset, const std::string& distanceType) { + configure(alignmentType, disExtension, disOnset, distanceType); +} +CoverSongSimilarity::~CoverSongSimilarity() { + delete _coversongsimilarity; +} +void CoverSongSimilarity::configure(const std::string& alignmentType, const float disExtension, const float disOnset, const std::string& distanceType) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _coversongsimilarity = factory.create("CoverSongSimilarity", "alignmentType", alignmentType, "disExtension", disExtension, "disOnset", disOnset, "distanceType", distanceType); +} +val CoverSongSimilarity::compute(std::vector >& input_inputArray) { + _coversongsimilarity->input("inputArray").set(input_inputArray); + std::vector > output_scoreMatrix; + float output_distance; + _coversongsimilarity->output("scoreMatrix").set(output_scoreMatrix); + _coversongsimilarity->output("distance").set(output_distance); + _coversongsimilarity->compute(); + val outputCoverSongSimilarity(val::object()); + outputCoverSongSimilarity.set("scoreMatrix", output_scoreMatrix); + outputCoverSongSimilarity.set("distance", output_distance); + return outputCoverSongSimilarity; +} +void CoverSongSimilarity::reset() { +_coversongsimilarity->reset(); +} +// END CoverSongSimilarity definitions + +// START Crest definitions // check https://essentia.upf.edu/reference/std_Crest.html -val EssentiaJS::Crest(std::vector& input_array) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoCrest = factory.create("Crest"); - algoCrest->input("array").set(input_array); - float output_crest; - algoCrest->output("crest").set(output_crest); - algoCrest->compute(); - val outputCrest(val::object()); - outputCrest.set("crest", output_crest); - delete algoCrest; - return outputCrest; -} - +Crest::Crest() { + configure(); +} +Crest::~Crest() { + delete _crest; +} +void Crest::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _crest = factory.create("Crest"); +} +val Crest::compute(std::vector& input_array) { + _crest->input("array").set(input_array); + float output_crest; + _crest->output("crest").set(output_crest); + _crest->compute(); + val outputCrest(val::object()); + outputCrest.set("crest", output_crest); + return outputCrest; +} +void Crest::reset() { +_crest->reset(); +} +// END Crest definitions + +// START CrossCorrelation definitions // check https://essentia.upf.edu/reference/std_CrossCorrelation.html -val EssentiaJS::CrossCorrelation(std::vector& input_arrayX, std::vector& input_arrayY, const int maxLag, const int minLag) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoCrossCorrelation = factory.create("CrossCorrelation", "maxLag", maxLag, "minLag", minLag); - algoCrossCorrelation->input("arrayX").set(input_arrayX); - algoCrossCorrelation->input("arrayY").set(input_arrayY); - std::vector output_crossCorrelation; - algoCrossCorrelation->output("crossCorrelation").set(output_crossCorrelation); - algoCrossCorrelation->compute(); - val outputCrossCorrelation(val::object()); - outputCrossCorrelation.set("crossCorrelation", output_crossCorrelation); - delete algoCrossCorrelation; - return outputCrossCorrelation; -} - +CrossCorrelation::CrossCorrelation(const int maxLag, const int minLag) { + configure(maxLag, minLag); +} +CrossCorrelation::~CrossCorrelation() { + delete _crosscorrelation; +} +void CrossCorrelation::configure(const int maxLag, const int minLag) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _crosscorrelation = factory.create("CrossCorrelation", "maxLag", maxLag, "minLag", minLag); +} +val CrossCorrelation::compute(std::vector& input_arrayX, std::vector& input_arrayY) { + _crosscorrelation->input("arrayX").set(input_arrayX); + _crosscorrelation->input("arrayY").set(input_arrayY); + std::vector output_crossCorrelation; + _crosscorrelation->output("crossCorrelation").set(output_crossCorrelation); + _crosscorrelation->compute(); + val outputCrossCorrelation(val::object()); + outputCrossCorrelation.set("crossCorrelation", output_crossCorrelation); + return outputCrossCorrelation; +} +void CrossCorrelation::reset() { +_crosscorrelation->reset(); +} +// END CrossCorrelation definitions + +// START CrossSimilarityMatrix definitions // check https://essentia.upf.edu/reference/std_CrossSimilarityMatrix.html -val EssentiaJS::CrossSimilarityMatrix(std::vector >& input_queryFeature, std::vector >& input_referenceFeature, const bool binarize, const float binarizePercentile, const int frameStackSize, const int frameStackStride) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoCrossSimilarityMatrix = factory.create("CrossSimilarityMatrix", "binarize", binarize, "binarizePercentile", binarizePercentile, "frameStackSize", frameStackSize, "frameStackStride", frameStackStride); - algoCrossSimilarityMatrix->input("queryFeature").set(input_queryFeature); - algoCrossSimilarityMatrix->input("referenceFeature").set(input_referenceFeature); - std::vector > output_csm; - algoCrossSimilarityMatrix->output("csm").set(output_csm); - algoCrossSimilarityMatrix->compute(); - val outputCrossSimilarityMatrix(val::object()); - outputCrossSimilarityMatrix.set("csm", output_csm); - delete algoCrossSimilarityMatrix; - return outputCrossSimilarityMatrix; -} - +CrossSimilarityMatrix::CrossSimilarityMatrix(const bool binarize, const float binarizePercentile, const int frameStackSize, const int frameStackStride) { + configure(binarize, binarizePercentile, frameStackSize, frameStackStride); +} +CrossSimilarityMatrix::~CrossSimilarityMatrix() { + delete _crosssimilaritymatrix; +} +void CrossSimilarityMatrix::configure(const bool binarize, const float binarizePercentile, const int frameStackSize, const int frameStackStride) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _crosssimilaritymatrix = factory.create("CrossSimilarityMatrix", "binarize", binarize, "binarizePercentile", binarizePercentile, "frameStackSize", frameStackSize, "frameStackStride", frameStackStride); +} +val CrossSimilarityMatrix::compute(std::vector >& input_queryFeature, std::vector >& input_referenceFeature) { + _crosssimilaritymatrix->input("queryFeature").set(input_queryFeature); + _crosssimilaritymatrix->input("referenceFeature").set(input_referenceFeature); + std::vector > output_csm; + _crosssimilaritymatrix->output("csm").set(output_csm); + _crosssimilaritymatrix->compute(); + val outputCrossSimilarityMatrix(val::object()); + outputCrossSimilarityMatrix.set("csm", output_csm); + return outputCrossSimilarityMatrix; +} +void CrossSimilarityMatrix::reset() { +_crosssimilaritymatrix->reset(); +} +// END CrossSimilarityMatrix definitions + +// START CubicSpline definitions // check https://essentia.upf.edu/reference/std_CubicSpline.html -val EssentiaJS::CubicSpline(float input_x, const int leftBoundaryFlag, const float leftBoundaryValue, const int rightBoundaryFlag, const float rightBoundaryValue, const std::vector& xPoints, const std::vector& yPoints) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoCubicSpline = factory.create("CubicSpline", "leftBoundaryFlag", leftBoundaryFlag, "leftBoundaryValue", leftBoundaryValue, "rightBoundaryFlag", rightBoundaryFlag, "rightBoundaryValue", rightBoundaryValue, "xPoints", xPoints, "yPoints", yPoints); - algoCubicSpline->input("x").set(input_x); - float output_y; - float output_dy; - float output_ddy; - algoCubicSpline->output("y").set(output_y); - algoCubicSpline->output("dy").set(output_dy); - algoCubicSpline->output("ddy").set(output_ddy); - algoCubicSpline->compute(); - val outputCubicSpline(val::object()); - outputCubicSpline.set("y", output_y); - outputCubicSpline.set("dy", output_dy); - outputCubicSpline.set("ddy", output_ddy); - delete algoCubicSpline; - return outputCubicSpline; -} - +CubicSpline::CubicSpline(const int leftBoundaryFlag, const float leftBoundaryValue, const int rightBoundaryFlag, const float rightBoundaryValue, const std::vector& xPoints, const std::vector& yPoints) { + configure(leftBoundaryFlag, leftBoundaryValue, rightBoundaryFlag, rightBoundaryValue, xPoints, yPoints); +} +CubicSpline::~CubicSpline() { + delete _cubicspline; +} +void CubicSpline::configure(const int leftBoundaryFlag, const float leftBoundaryValue, const int rightBoundaryFlag, const float rightBoundaryValue, const std::vector& xPoints, const std::vector& yPoints) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _cubicspline = factory.create("CubicSpline", "leftBoundaryFlag", leftBoundaryFlag, "leftBoundaryValue", leftBoundaryValue, "rightBoundaryFlag", rightBoundaryFlag, "rightBoundaryValue", rightBoundaryValue, "xPoints", xPoints, "yPoints", yPoints); +} +val CubicSpline::compute(float input_x) { + _cubicspline->input("x").set(input_x); + float output_y; + float output_dy; + float output_ddy; + _cubicspline->output("y").set(output_y); + _cubicspline->output("dy").set(output_dy); + _cubicspline->output("ddy").set(output_ddy); + _cubicspline->compute(); + val outputCubicSpline(val::object()); + outputCubicSpline.set("y", output_y); + outputCubicSpline.set("dy", output_dy); + outputCubicSpline.set("ddy", output_ddy); + return outputCubicSpline; +} +void CubicSpline::reset() { +_cubicspline->reset(); +} +// END CubicSpline definitions + +// START DCRemoval definitions // check https://essentia.upf.edu/reference/std_DCRemoval.html -val EssentiaJS::DCRemoval(std::vector& input_signal, const float cutoffFrequency, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoDCRemoval = factory.create("DCRemoval", "cutoffFrequency", cutoffFrequency, "sampleRate", sampleRate); - algoDCRemoval->input("signal").set(input_signal); - std::vector output_signal; - algoDCRemoval->output("signal").set(output_signal); - algoDCRemoval->compute(); - val outputDCRemoval(val::object()); - outputDCRemoval.set("signal", output_signal); - delete algoDCRemoval; - return outputDCRemoval; -} - +DCRemoval::DCRemoval(const float cutoffFrequency, const float sampleRate) { + configure(cutoffFrequency, sampleRate); +} +DCRemoval::~DCRemoval() { + delete _dcremoval; +} +void DCRemoval::configure(const float cutoffFrequency, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _dcremoval = factory.create("DCRemoval", "cutoffFrequency", cutoffFrequency, "sampleRate", sampleRate); +} +val DCRemoval::compute(std::vector& input_signal) { + _dcremoval->input("signal").set(input_signal); + std::vector output_signal; + _dcremoval->output("signal").set(output_signal); + _dcremoval->compute(); + val outputDCRemoval(val::object()); + outputDCRemoval.set("signal", output_signal); + return outputDCRemoval; +} +void DCRemoval::reset() { +_dcremoval->reset(); +} +// END DCRemoval definitions + +// START DCT definitions // check https://essentia.upf.edu/reference/std_DCT.html -val EssentiaJS::DCT(std::vector& input_array, const int dctType, const int inputSize, const int liftering, const int outputSize) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoDCT = factory.create("DCT", "dctType", dctType, "inputSize", inputSize, "liftering", liftering, "outputSize", outputSize); - algoDCT->input("array").set(input_array); - std::vector output_dct; - algoDCT->output("dct").set(output_dct); - algoDCT->compute(); - val outputDCT(val::object()); - outputDCT.set("dct", output_dct); - delete algoDCT; - return outputDCT; -} - +DCT::DCT(const int dctType, const int inputSize, const int liftering, const int outputSize) { + configure(dctType, inputSize, liftering, outputSize); +} +DCT::~DCT() { + delete _dct; +} +void DCT::configure(const int dctType, const int inputSize, const int liftering, const int outputSize) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _dct = factory.create("DCT", "dctType", dctType, "inputSize", inputSize, "liftering", liftering, "outputSize", outputSize); +} +val DCT::compute(std::vector& input_array) { + _dct->input("array").set(input_array); + std::vector output_dct; + _dct->output("dct").set(output_dct); + _dct->compute(); + val outputDCT(val::object()); + outputDCT.set("dct", output_dct); + return outputDCT; +} +void DCT::reset() { +_dct->reset(); +} +// END DCT definitions + +// START Danceability definitions // check https://essentia.upf.edu/reference/std_Danceability.html -val EssentiaJS::Danceability(std::vector& input_signal, const float maxTau, const float minTau, const float sampleRate, const float tauMultiplier) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoDanceability = factory.create("Danceability", "maxTau", maxTau, "minTau", minTau, "sampleRate", sampleRate, "tauMultiplier", tauMultiplier); - algoDanceability->input("signal").set(input_signal); - float output_danceability; - std::vector output_dfa; - algoDanceability->output("danceability").set(output_danceability); - algoDanceability->output("dfa").set(output_dfa); - algoDanceability->compute(); - val outputDanceability(val::object()); - outputDanceability.set("danceability", output_danceability); - outputDanceability.set("dfa", output_dfa); - delete algoDanceability; - return outputDanceability; -} - +Danceability::Danceability(const float maxTau, const float minTau, const float sampleRate, const float tauMultiplier) { + configure(maxTau, minTau, sampleRate, tauMultiplier); +} +Danceability::~Danceability() { + delete _danceability; +} +void Danceability::configure(const float maxTau, const float minTau, const float sampleRate, const float tauMultiplier) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _danceability = factory.create("Danceability", "maxTau", maxTau, "minTau", minTau, "sampleRate", sampleRate, "tauMultiplier", tauMultiplier); +} +val Danceability::compute(std::vector& input_signal) { + _danceability->input("signal").set(input_signal); + float output_danceability; + std::vector output_dfa; + _danceability->output("danceability").set(output_danceability); + _danceability->output("dfa").set(output_dfa); + _danceability->compute(); + val outputDanceability(val::object()); + outputDanceability.set("danceability", output_danceability); + outputDanceability.set("dfa", output_dfa); + return outputDanceability; +} +void Danceability::reset() { +_danceability->reset(); +} +// END Danceability definitions + +// START Decrease definitions // check https://essentia.upf.edu/reference/std_Decrease.html -val EssentiaJS::Decrease(std::vector& input_array, const float range) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoDecrease = factory.create("Decrease", "range", range); - algoDecrease->input("array").set(input_array); - float output_decrease; - algoDecrease->output("decrease").set(output_decrease); - algoDecrease->compute(); - val outputDecrease(val::object()); - outputDecrease.set("decrease", output_decrease); - delete algoDecrease; - return outputDecrease; -} - +Decrease::Decrease(const float range) { + configure(range); +} +Decrease::~Decrease() { + delete _decrease; +} +void Decrease::configure(const float range) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _decrease = factory.create("Decrease", "range", range); +} +val Decrease::compute(std::vector& input_array) { + _decrease->input("array").set(input_array); + float output_decrease; + _decrease->output("decrease").set(output_decrease); + _decrease->compute(); + val outputDecrease(val::object()); + outputDecrease.set("decrease", output_decrease); + return outputDecrease; +} +void Decrease::reset() { +_decrease->reset(); +} +// END Decrease definitions + +// START Derivative definitions // check https://essentia.upf.edu/reference/std_Derivative.html -val EssentiaJS::Derivative(std::vector& input_signal) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoDerivative = factory.create("Derivative"); - algoDerivative->input("signal").set(input_signal); - std::vector output_signal; - algoDerivative->output("signal").set(output_signal); - algoDerivative->compute(); - val outputDerivative(val::object()); - outputDerivative.set("signal", output_signal); - delete algoDerivative; - return outputDerivative; -} - +Derivative::Derivative() { + configure(); +} +Derivative::~Derivative() { + delete _derivative; +} +void Derivative::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _derivative = factory.create("Derivative"); +} +val Derivative::compute(std::vector& input_signal) { + _derivative->input("signal").set(input_signal); + std::vector output_signal; + _derivative->output("signal").set(output_signal); + _derivative->compute(); + val outputDerivative(val::object()); + outputDerivative.set("signal", output_signal); + return outputDerivative; +} +void Derivative::reset() { +_derivative->reset(); +} +// END Derivative definitions + +// START DerivativeSFX definitions // check https://essentia.upf.edu/reference/std_DerivativeSFX.html -val EssentiaJS::DerivativeSFX(std::vector& input_envelope) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoDerivativeSFX = factory.create("DerivativeSFX"); - algoDerivativeSFX->input("envelope").set(input_envelope); - float output_derAvAfterMax; - float output_maxDerBeforeMax; - algoDerivativeSFX->output("derAvAfterMax").set(output_derAvAfterMax); - algoDerivativeSFX->output("maxDerBeforeMax").set(output_maxDerBeforeMax); - algoDerivativeSFX->compute(); - val outputDerivativeSFX(val::object()); - outputDerivativeSFX.set("derAvAfterMax", output_derAvAfterMax); - outputDerivativeSFX.set("maxDerBeforeMax", output_maxDerBeforeMax); - delete algoDerivativeSFX; - return outputDerivativeSFX; -} - +DerivativeSFX::DerivativeSFX() { + configure(); +} +DerivativeSFX::~DerivativeSFX() { + delete _derivativesfx; +} +void DerivativeSFX::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _derivativesfx = factory.create("DerivativeSFX"); +} +val DerivativeSFX::compute(std::vector& input_envelope) { + _derivativesfx->input("envelope").set(input_envelope); + float output_derAvAfterMax; + float output_maxDerBeforeMax; + _derivativesfx->output("derAvAfterMax").set(output_derAvAfterMax); + _derivativesfx->output("maxDerBeforeMax").set(output_maxDerBeforeMax); + _derivativesfx->compute(); + val outputDerivativeSFX(val::object()); + outputDerivativeSFX.set("derAvAfterMax", output_derAvAfterMax); + outputDerivativeSFX.set("maxDerBeforeMax", output_maxDerBeforeMax); + return outputDerivativeSFX; +} +void DerivativeSFX::reset() { +_derivativesfx->reset(); +} +// END DerivativeSFX definitions + +// START DiscontinuityDetector definitions // check https://essentia.upf.edu/reference/std_DiscontinuityDetector.html -val EssentiaJS::DiscontinuityDetector(std::vector& input_frame, const float detectionThreshold, const float energyThreshold, const int frameSize, const int hopSize, const int kernelSize, const int order, const int silenceThreshold, const int subFrameSize) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoDiscontinuityDetector = factory.create("DiscontinuityDetector", "detectionThreshold", detectionThreshold, "energyThreshold", energyThreshold, "frameSize", frameSize, "hopSize", hopSize, "kernelSize", kernelSize, "order", order, "silenceThreshold", silenceThreshold, "subFrameSize", subFrameSize); - algoDiscontinuityDetector->input("frame").set(input_frame); - std::vector output_discontinuityLocations; - std::vector output_discontinuityAmplitudes; - algoDiscontinuityDetector->output("discontinuityLocations").set(output_discontinuityLocations); - algoDiscontinuityDetector->output("discontinuityAmplitudes").set(output_discontinuityAmplitudes); - algoDiscontinuityDetector->compute(); - val outputDiscontinuityDetector(val::object()); - outputDiscontinuityDetector.set("discontinuityLocations", output_discontinuityLocations); - outputDiscontinuityDetector.set("discontinuityAmplitudes", output_discontinuityAmplitudes); - delete algoDiscontinuityDetector; - return outputDiscontinuityDetector; -} - +DiscontinuityDetector::DiscontinuityDetector(const float detectionThreshold, const float energyThreshold, const int frameSize, const int hopSize, const int kernelSize, const int order, const int silenceThreshold, const int subFrameSize) { + configure(detectionThreshold, energyThreshold, frameSize, hopSize, kernelSize, order, silenceThreshold, subFrameSize); +} +DiscontinuityDetector::~DiscontinuityDetector() { + delete _discontinuitydetector; +} +void DiscontinuityDetector::configure(const float detectionThreshold, const float energyThreshold, const int frameSize, const int hopSize, const int kernelSize, const int order, const int silenceThreshold, const int subFrameSize) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _discontinuitydetector = factory.create("DiscontinuityDetector", "detectionThreshold", detectionThreshold, "energyThreshold", energyThreshold, "frameSize", frameSize, "hopSize", hopSize, "kernelSize", kernelSize, "order", order, "silenceThreshold", silenceThreshold, "subFrameSize", subFrameSize); +} +val DiscontinuityDetector::compute(std::vector& input_frame) { + _discontinuitydetector->input("frame").set(input_frame); + std::vector output_discontinuityLocations; + std::vector output_discontinuityAmplitudes; + _discontinuitydetector->output("discontinuityLocations").set(output_discontinuityLocations); + _discontinuitydetector->output("discontinuityAmplitudes").set(output_discontinuityAmplitudes); + _discontinuitydetector->compute(); + val outputDiscontinuityDetector(val::object()); + outputDiscontinuityDetector.set("discontinuityLocations", output_discontinuityLocations); + outputDiscontinuityDetector.set("discontinuityAmplitudes", output_discontinuityAmplitudes); + return outputDiscontinuityDetector; +} +void DiscontinuityDetector::reset() { +_discontinuitydetector->reset(); +} +// END DiscontinuityDetector definitions + +// START Dissonance definitions // check https://essentia.upf.edu/reference/std_Dissonance.html -val EssentiaJS::Dissonance(std::vector& input_frequencies, std::vector& input_magnitudes) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoDissonance = factory.create("Dissonance"); - algoDissonance->input("frequencies").set(input_frequencies); - algoDissonance->input("magnitudes").set(input_magnitudes); - float output_dissonance; - algoDissonance->output("dissonance").set(output_dissonance); - algoDissonance->compute(); - val outputDissonance(val::object()); - outputDissonance.set("dissonance", output_dissonance); - delete algoDissonance; - return outputDissonance; -} - +Dissonance::Dissonance() { + configure(); +} +Dissonance::~Dissonance() { + delete _dissonance; +} +void Dissonance::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _dissonance = factory.create("Dissonance"); +} +val Dissonance::compute(std::vector& input_frequencies, std::vector& input_magnitudes) { + _dissonance->input("frequencies").set(input_frequencies); + _dissonance->input("magnitudes").set(input_magnitudes); + float output_dissonance; + _dissonance->output("dissonance").set(output_dissonance); + _dissonance->compute(); + val outputDissonance(val::object()); + outputDissonance.set("dissonance", output_dissonance); + return outputDissonance; +} +void Dissonance::reset() { +_dissonance->reset(); +} +// END Dissonance definitions + +// START DistributionShape definitions // check https://essentia.upf.edu/reference/std_DistributionShape.html -val EssentiaJS::DistributionShape(std::vector& input_centralMoments) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoDistributionShape = factory.create("DistributionShape"); - algoDistributionShape->input("centralMoments").set(input_centralMoments); - float output_spread; - float output_skewness; - float output_kurtosis; - algoDistributionShape->output("spread").set(output_spread); - algoDistributionShape->output("skewness").set(output_skewness); - algoDistributionShape->output("kurtosis").set(output_kurtosis); - algoDistributionShape->compute(); - val outputDistributionShape(val::object()); - outputDistributionShape.set("spread", output_spread); - outputDistributionShape.set("skewness", output_skewness); - outputDistributionShape.set("kurtosis", output_kurtosis); - delete algoDistributionShape; - return outputDistributionShape; -} - +DistributionShape::DistributionShape() { + configure(); +} +DistributionShape::~DistributionShape() { + delete _distributionshape; +} +void DistributionShape::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _distributionshape = factory.create("DistributionShape"); +} +val DistributionShape::compute(std::vector& input_centralMoments) { + _distributionshape->input("centralMoments").set(input_centralMoments); + float output_spread; + float output_skewness; + float output_kurtosis; + _distributionshape->output("spread").set(output_spread); + _distributionshape->output("skewness").set(output_skewness); + _distributionshape->output("kurtosis").set(output_kurtosis); + _distributionshape->compute(); + val outputDistributionShape(val::object()); + outputDistributionShape.set("spread", output_spread); + outputDistributionShape.set("skewness", output_skewness); + outputDistributionShape.set("kurtosis", output_kurtosis); + return outputDistributionShape; +} +void DistributionShape::reset() { +_distributionshape->reset(); +} +// END DistributionShape definitions + +// START Duration definitions // check https://essentia.upf.edu/reference/std_Duration.html -val EssentiaJS::Duration(std::vector& input_signal, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoDuration = factory.create("Duration", "sampleRate", sampleRate); - algoDuration->input("signal").set(input_signal); - float output_duration; - algoDuration->output("duration").set(output_duration); - algoDuration->compute(); - val outputDuration(val::object()); - outputDuration.set("duration", output_duration); - delete algoDuration; - return outputDuration; -} - +Duration::Duration(const float sampleRate) { + configure(sampleRate); +} +Duration::~Duration() { + delete _duration; +} +void Duration::configure(const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _duration = factory.create("Duration", "sampleRate", sampleRate); +} +val Duration::compute(std::vector& input_signal) { + _duration->input("signal").set(input_signal); + float output_duration; + _duration->output("duration").set(output_duration); + _duration->compute(); + val outputDuration(val::object()); + outputDuration.set("duration", output_duration); + return outputDuration; +} +void Duration::reset() { +_duration->reset(); +} +// END Duration definitions + +// START DynamicComplexity definitions // check https://essentia.upf.edu/reference/std_DynamicComplexity.html -val EssentiaJS::DynamicComplexity(std::vector& input_signal, const float frameSize, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoDynamicComplexity = factory.create("DynamicComplexity", "frameSize", frameSize, "sampleRate", sampleRate); - algoDynamicComplexity->input("signal").set(input_signal); - float output_dynamicComplexity; - float output_loudness; - algoDynamicComplexity->output("dynamicComplexity").set(output_dynamicComplexity); - algoDynamicComplexity->output("loudness").set(output_loudness); - algoDynamicComplexity->compute(); - val outputDynamicComplexity(val::object()); - outputDynamicComplexity.set("dynamicComplexity", output_dynamicComplexity); - outputDynamicComplexity.set("loudness", output_loudness); - delete algoDynamicComplexity; - return outputDynamicComplexity; -} - +DynamicComplexity::DynamicComplexity(const float frameSize, const float sampleRate) { + configure(frameSize, sampleRate); +} +DynamicComplexity::~DynamicComplexity() { + delete _dynamiccomplexity; +} +void DynamicComplexity::configure(const float frameSize, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _dynamiccomplexity = factory.create("DynamicComplexity", "frameSize", frameSize, "sampleRate", sampleRate); +} +val DynamicComplexity::compute(std::vector& input_signal) { + _dynamiccomplexity->input("signal").set(input_signal); + float output_dynamicComplexity; + float output_loudness; + _dynamiccomplexity->output("dynamicComplexity").set(output_dynamicComplexity); + _dynamiccomplexity->output("loudness").set(output_loudness); + _dynamiccomplexity->compute(); + val outputDynamicComplexity(val::object()); + outputDynamicComplexity.set("dynamicComplexity", output_dynamicComplexity); + outputDynamicComplexity.set("loudness", output_loudness); + return outputDynamicComplexity; +} +void DynamicComplexity::reset() { +_dynamiccomplexity->reset(); +} +// END DynamicComplexity definitions + +// START ERBBands definitions // check https://essentia.upf.edu/reference/std_ERBBands.html -val EssentiaJS::ERBBands(std::vector& input_spectrum, const float highFrequencyBound, const int inputSize, const float lowFrequencyBound, const int numberBands, const float sampleRate, const std::string& type, const float width) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoERBBands = factory.create("ERBBands", "highFrequencyBound", highFrequencyBound, "inputSize", inputSize, "lowFrequencyBound", lowFrequencyBound, "numberBands", numberBands, "sampleRate", sampleRate, "type", type, "width", width); - algoERBBands->input("spectrum").set(input_spectrum); - std::vector output_bands; - algoERBBands->output("bands").set(output_bands); - algoERBBands->compute(); - val outputERBBands(val::object()); - outputERBBands.set("bands", output_bands); - delete algoERBBands; - return outputERBBands; -} - +ERBBands::ERBBands(const float highFrequencyBound, const int inputSize, const float lowFrequencyBound, const int numberBands, const float sampleRate, const std::string& type, const float width) { + configure(highFrequencyBound, inputSize, lowFrequencyBound, numberBands, sampleRate, type, width); +} +ERBBands::~ERBBands() { + delete _erbbands; +} +void ERBBands::configure(const float highFrequencyBound, const int inputSize, const float lowFrequencyBound, const int numberBands, const float sampleRate, const std::string& type, const float width) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _erbbands = factory.create("ERBBands", "highFrequencyBound", highFrequencyBound, "inputSize", inputSize, "lowFrequencyBound", lowFrequencyBound, "numberBands", numberBands, "sampleRate", sampleRate, "type", type, "width", width); +} +val ERBBands::compute(std::vector& input_spectrum) { + _erbbands->input("spectrum").set(input_spectrum); + std::vector output_bands; + _erbbands->output("bands").set(output_bands); + _erbbands->compute(); + val outputERBBands(val::object()); + outputERBBands.set("bands", output_bands); + return outputERBBands; +} +void ERBBands::reset() { +_erbbands->reset(); +} +// END ERBBands definitions + +// START EffectiveDuration definitions // check https://essentia.upf.edu/reference/std_EffectiveDuration.html -val EssentiaJS::EffectiveDuration(std::vector& input_signal, const float sampleRate, const float thresholdRatio) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoEffectiveDuration = factory.create("EffectiveDuration", "sampleRate", sampleRate, "thresholdRatio", thresholdRatio); - algoEffectiveDuration->input("signal").set(input_signal); - float output_effectiveDuration; - algoEffectiveDuration->output("effectiveDuration").set(output_effectiveDuration); - algoEffectiveDuration->compute(); - val outputEffectiveDuration(val::object()); - outputEffectiveDuration.set("effectiveDuration", output_effectiveDuration); - delete algoEffectiveDuration; - return outputEffectiveDuration; -} - +EffectiveDuration::EffectiveDuration(const float sampleRate, const float thresholdRatio) { + configure(sampleRate, thresholdRatio); +} +EffectiveDuration::~EffectiveDuration() { + delete _effectiveduration; +} +void EffectiveDuration::configure(const float sampleRate, const float thresholdRatio) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _effectiveduration = factory.create("EffectiveDuration", "sampleRate", sampleRate, "thresholdRatio", thresholdRatio); +} +val EffectiveDuration::compute(std::vector& input_signal) { + _effectiveduration->input("signal").set(input_signal); + float output_effectiveDuration; + _effectiveduration->output("effectiveDuration").set(output_effectiveDuration); + _effectiveduration->compute(); + val outputEffectiveDuration(val::object()); + outputEffectiveDuration.set("effectiveDuration", output_effectiveDuration); + return outputEffectiveDuration; +} +void EffectiveDuration::reset() { +_effectiveduration->reset(); +} +// END EffectiveDuration definitions + +// START Energy definitions // check https://essentia.upf.edu/reference/std_Energy.html -val EssentiaJS::Energy(std::vector& input_array) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoEnergy = factory.create("Energy"); - algoEnergy->input("array").set(input_array); - float output_energy; - algoEnergy->output("energy").set(output_energy); - algoEnergy->compute(); - val outputEnergy(val::object()); - outputEnergy.set("energy", output_energy); - delete algoEnergy; - return outputEnergy; -} - +Energy::Energy() { + configure(); +} +Energy::~Energy() { + delete _energy; +} +void Energy::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _energy = factory.create("Energy"); +} +val Energy::compute(std::vector& input_array) { + _energy->input("array").set(input_array); + float output_energy; + _energy->output("energy").set(output_energy); + _energy->compute(); + val outputEnergy(val::object()); + outputEnergy.set("energy", output_energy); + return outputEnergy; +} +void Energy::reset() { +_energy->reset(); +} +// END Energy definitions + +// START EnergyBand definitions // check https://essentia.upf.edu/reference/std_EnergyBand.html -val EssentiaJS::EnergyBand(std::vector& input_spectrum, const float sampleRate, const float startCutoffFrequency, const float stopCutoffFrequency) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoEnergyBand = factory.create("EnergyBand", "sampleRate", sampleRate, "startCutoffFrequency", startCutoffFrequency, "stopCutoffFrequency", stopCutoffFrequency); - algoEnergyBand->input("spectrum").set(input_spectrum); - float output_energyBand; - algoEnergyBand->output("energyBand").set(output_energyBand); - algoEnergyBand->compute(); - val outputEnergyBand(val::object()); - outputEnergyBand.set("energyBand", output_energyBand); - delete algoEnergyBand; - return outputEnergyBand; -} - +EnergyBand::EnergyBand(const float sampleRate, const float startCutoffFrequency, const float stopCutoffFrequency) { + configure(sampleRate, startCutoffFrequency, stopCutoffFrequency); +} +EnergyBand::~EnergyBand() { + delete _energyband; +} +void EnergyBand::configure(const float sampleRate, const float startCutoffFrequency, const float stopCutoffFrequency) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _energyband = factory.create("EnergyBand", "sampleRate", sampleRate, "startCutoffFrequency", startCutoffFrequency, "stopCutoffFrequency", stopCutoffFrequency); +} +val EnergyBand::compute(std::vector& input_spectrum) { + _energyband->input("spectrum").set(input_spectrum); + float output_energyBand; + _energyband->output("energyBand").set(output_energyBand); + _energyband->compute(); + val outputEnergyBand(val::object()); + outputEnergyBand.set("energyBand", output_energyBand); + return outputEnergyBand; +} +void EnergyBand::reset() { +_energyband->reset(); +} +// END EnergyBand definitions + +// START EnergyBandRatio definitions // check https://essentia.upf.edu/reference/std_EnergyBandRatio.html -val EssentiaJS::EnergyBandRatio(std::vector& input_spectrum, const float sampleRate, const float startFrequency, const float stopFrequency) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoEnergyBandRatio = factory.create("EnergyBandRatio", "sampleRate", sampleRate, "startFrequency", startFrequency, "stopFrequency", stopFrequency); - algoEnergyBandRatio->input("spectrum").set(input_spectrum); - float output_energyBandRatio; - algoEnergyBandRatio->output("energyBandRatio").set(output_energyBandRatio); - algoEnergyBandRatio->compute(); - val outputEnergyBandRatio(val::object()); - outputEnergyBandRatio.set("energyBandRatio", output_energyBandRatio); - delete algoEnergyBandRatio; - return outputEnergyBandRatio; -} - +EnergyBandRatio::EnergyBandRatio(const float sampleRate, const float startFrequency, const float stopFrequency) { + configure(sampleRate, startFrequency, stopFrequency); +} +EnergyBandRatio::~EnergyBandRatio() { + delete _energybandratio; +} +void EnergyBandRatio::configure(const float sampleRate, const float startFrequency, const float stopFrequency) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _energybandratio = factory.create("EnergyBandRatio", "sampleRate", sampleRate, "startFrequency", startFrequency, "stopFrequency", stopFrequency); +} +val EnergyBandRatio::compute(std::vector& input_spectrum) { + _energybandratio->input("spectrum").set(input_spectrum); + float output_energyBandRatio; + _energybandratio->output("energyBandRatio").set(output_energyBandRatio); + _energybandratio->compute(); + val outputEnergyBandRatio(val::object()); + outputEnergyBandRatio.set("energyBandRatio", output_energyBandRatio); + return outputEnergyBandRatio; +} +void EnergyBandRatio::reset() { +_energybandratio->reset(); +} +// END EnergyBandRatio definitions + +// START Entropy definitions // check https://essentia.upf.edu/reference/std_Entropy.html -val EssentiaJS::Entropy(std::vector& input_array) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoEntropy = factory.create("Entropy"); - algoEntropy->input("array").set(input_array); - float output_entropy; - algoEntropy->output("entropy").set(output_entropy); - algoEntropy->compute(); - val outputEntropy(val::object()); - outputEntropy.set("entropy", output_entropy); - delete algoEntropy; - return outputEntropy; -} - +Entropy::Entropy() { + configure(); +} +Entropy::~Entropy() { + delete _entropy; +} +void Entropy::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _entropy = factory.create("Entropy"); +} +val Entropy::compute(std::vector& input_array) { + _entropy->input("array").set(input_array); + float output_entropy; + _entropy->output("entropy").set(output_entropy); + _entropy->compute(); + val outputEntropy(val::object()); + outputEntropy.set("entropy", output_entropy); + return outputEntropy; +} +void Entropy::reset() { +_entropy->reset(); +} +// END Entropy definitions + +// START Envelope definitions // check https://essentia.upf.edu/reference/std_Envelope.html -val EssentiaJS::Envelope(std::vector& input_signal, const bool applyRectification, const float attackTime, const float releaseTime, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoEnvelope = factory.create("Envelope", "applyRectification", applyRectification, "attackTime", attackTime, "releaseTime", releaseTime, "sampleRate", sampleRate); - algoEnvelope->input("signal").set(input_signal); - std::vector output_signal; - algoEnvelope->output("signal").set(output_signal); - algoEnvelope->compute(); - val outputEnvelope(val::object()); - outputEnvelope.set("signal", output_signal); - delete algoEnvelope; - return outputEnvelope; -} - +Envelope::Envelope(const bool applyRectification, const float attackTime, const float releaseTime, const float sampleRate) { + configure(applyRectification, attackTime, releaseTime, sampleRate); +} +Envelope::~Envelope() { + delete _envelope; +} +void Envelope::configure(const bool applyRectification, const float attackTime, const float releaseTime, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _envelope = factory.create("Envelope", "applyRectification", applyRectification, "attackTime", attackTime, "releaseTime", releaseTime, "sampleRate", sampleRate); +} +val Envelope::compute(std::vector& input_signal) { + _envelope->input("signal").set(input_signal); + std::vector output_signal; + _envelope->output("signal").set(output_signal); + _envelope->compute(); + val outputEnvelope(val::object()); + outputEnvelope.set("signal", output_signal); + return outputEnvelope; +} +void Envelope::reset() { +_envelope->reset(); +} +// END Envelope definitions + +// START EqualLoudness definitions // check https://essentia.upf.edu/reference/std_EqualLoudness.html -val EssentiaJS::EqualLoudness(std::vector& input_signal, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoEqualLoudness = factory.create("EqualLoudness", "sampleRate", sampleRate); - algoEqualLoudness->input("signal").set(input_signal); - std::vector output_signal; - algoEqualLoudness->output("signal").set(output_signal); - algoEqualLoudness->compute(); - val outputEqualLoudness(val::object()); - outputEqualLoudness.set("signal", output_signal); - delete algoEqualLoudness; - return outputEqualLoudness; -} - +EqualLoudness::EqualLoudness(const float sampleRate) { + configure(sampleRate); +} +EqualLoudness::~EqualLoudness() { + delete _equalloudness; +} +void EqualLoudness::configure(const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _equalloudness = factory.create("EqualLoudness", "sampleRate", sampleRate); +} +val EqualLoudness::compute(std::vector& input_signal) { + _equalloudness->input("signal").set(input_signal); + std::vector output_signal; + _equalloudness->output("signal").set(output_signal); + _equalloudness->compute(); + val outputEqualLoudness(val::object()); + outputEqualLoudness.set("signal", output_signal); + return outputEqualLoudness; +} +void EqualLoudness::reset() { +_equalloudness->reset(); +} +// END EqualLoudness definitions + +// START Flatness definitions // check https://essentia.upf.edu/reference/std_Flatness.html -val EssentiaJS::Flatness(std::vector& input_array) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoFlatness = factory.create("Flatness"); - algoFlatness->input("array").set(input_array); - float output_flatness; - algoFlatness->output("flatness").set(output_flatness); - algoFlatness->compute(); - val outputFlatness(val::object()); - outputFlatness.set("flatness", output_flatness); - delete algoFlatness; - return outputFlatness; -} - -// check https://essentia.upf.edu/reference/std_FlatnessDB.html -val EssentiaJS::FlatnessDB(std::vector& input_array) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoFlatnessDB = factory.create("FlatnessDB"); - algoFlatnessDB->input("array").set(input_array); - float output_flatnessDB; - algoFlatnessDB->output("flatnessDB").set(output_flatnessDB); - algoFlatnessDB->compute(); - val outputFlatnessDB(val::object()); - outputFlatnessDB.set("flatnessDB", output_flatnessDB); - delete algoFlatnessDB; - return outputFlatnessDB; -} - +Flatness::Flatness() { + configure(); +} +Flatness::~Flatness() { + delete _flatness; +} +void Flatness::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _flatness = factory.create("Flatness"); +} +val Flatness::compute(std::vector& input_array) { + _flatness->input("array").set(input_array); + float output_flatness; + _flatness->output("flatness").set(output_flatness); + _flatness->compute(); + val outputFlatness(val::object()); + outputFlatness.set("flatness", output_flatness); + return outputFlatness; +} +void Flatness::reset() { +_flatness->reset(); +} +// END Flatness definitions + +// START FlatnessDB definitions +// check https://essentia.upf.edu/reference/std_FlatnessDB.html +FlatnessDB::FlatnessDB() { + configure(); +} +FlatnessDB::~FlatnessDB() { + delete _flatnessdb; +} +void FlatnessDB::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _flatnessdb = factory.create("FlatnessDB"); +} +val FlatnessDB::compute(std::vector& input_array) { + _flatnessdb->input("array").set(input_array); + float output_flatnessDB; + _flatnessdb->output("flatnessDB").set(output_flatnessDB); + _flatnessdb->compute(); + val outputFlatnessDB(val::object()); + outputFlatnessDB.set("flatnessDB", output_flatnessDB); + return outputFlatnessDB; +} +void FlatnessDB::reset() { +_flatnessdb->reset(); +} +// END FlatnessDB definitions + +// START FlatnessSFX definitions // check https://essentia.upf.edu/reference/std_FlatnessSFX.html -val EssentiaJS::FlatnessSFX(std::vector& input_envelope) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoFlatnessSFX = factory.create("FlatnessSFX"); - algoFlatnessSFX->input("envelope").set(input_envelope); - float output_flatness; - algoFlatnessSFX->output("flatness").set(output_flatness); - algoFlatnessSFX->compute(); - val outputFlatnessSFX(val::object()); - outputFlatnessSFX.set("flatness", output_flatness); - delete algoFlatnessSFX; - return outputFlatnessSFX; -} - +FlatnessSFX::FlatnessSFX() { + configure(); +} +FlatnessSFX::~FlatnessSFX() { + delete _flatnesssfx; +} +void FlatnessSFX::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _flatnesssfx = factory.create("FlatnessSFX"); +} +val FlatnessSFX::compute(std::vector& input_envelope) { + _flatnesssfx->input("envelope").set(input_envelope); + float output_flatness; + _flatnesssfx->output("flatness").set(output_flatness); + _flatnesssfx->compute(); + val outputFlatnessSFX(val::object()); + outputFlatnessSFX.set("flatness", output_flatness); + return outputFlatnessSFX; +} +void FlatnessSFX::reset() { +_flatnesssfx->reset(); +} +// END FlatnessSFX definitions + +// START Flux definitions // check https://essentia.upf.edu/reference/std_Flux.html -val EssentiaJS::Flux(std::vector& input_spectrum, const bool halfRectify, const std::string& norm) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoFlux = factory.create("Flux", "halfRectify", halfRectify, "norm", norm); - algoFlux->input("spectrum").set(input_spectrum); - float output_flux; - algoFlux->output("flux").set(output_flux); - algoFlux->compute(); - val outputFlux(val::object()); - outputFlux.set("flux", output_flux); - delete algoFlux; - return outputFlux; -} - +Flux::Flux(const bool halfRectify, const std::string& norm) { + configure(halfRectify, norm); +} +Flux::~Flux() { + delete _flux; +} +void Flux::configure(const bool halfRectify, const std::string& norm) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _flux = factory.create("Flux", "halfRectify", halfRectify, "norm", norm); +} +val Flux::compute(std::vector& input_spectrum) { + _flux->input("spectrum").set(input_spectrum); + float output_flux; + _flux->output("flux").set(output_flux); + _flux->compute(); + val outputFlux(val::object()); + outputFlux.set("flux", output_flux); + return outputFlux; +} +void Flux::reset() { +_flux->reset(); +} +// END Flux definitions + +// START FrameCutter definitions // check https://essentia.upf.edu/reference/std_FrameCutter.html -val EssentiaJS::FrameCutter(std::vector& input_signal, const int frameSize, const int hopSize, const bool lastFrameToEndOfFile, const bool startFromZero, const float validFrameThresholdRatio) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoFrameCutter = factory.create("FrameCutter", "frameSize", frameSize, "hopSize", hopSize, "lastFrameToEndOfFile", lastFrameToEndOfFile, "startFromZero", startFromZero, "validFrameThresholdRatio", validFrameThresholdRatio); - algoFrameCutter->input("signal").set(input_signal); - std::vector output_frame; - algoFrameCutter->output("frame").set(output_frame); - algoFrameCutter->compute(); - val outputFrameCutter(val::object()); - outputFrameCutter.set("frame", output_frame); - delete algoFrameCutter; - return outputFrameCutter; -} - +FrameCutter::FrameCutter(const int frameSize, const int hopSize, const bool lastFrameToEndOfFile, const bool startFromZero, const float validFrameThresholdRatio) { + configure(frameSize, hopSize, lastFrameToEndOfFile, startFromZero, validFrameThresholdRatio); +} +FrameCutter::~FrameCutter() { + delete _framecutter; +} +void FrameCutter::configure(const int frameSize, const int hopSize, const bool lastFrameToEndOfFile, const bool startFromZero, const float validFrameThresholdRatio) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _framecutter = factory.create("FrameCutter", "frameSize", frameSize, "hopSize", hopSize, "lastFrameToEndOfFile", lastFrameToEndOfFile, "startFromZero", startFromZero, "validFrameThresholdRatio", validFrameThresholdRatio); +} +val FrameCutter::compute(std::vector& input_signal) { + _framecutter->input("signal").set(input_signal); + std::vector output_frame; + _framecutter->output("frame").set(output_frame); + _framecutter->compute(); + val outputFrameCutter(val::object()); + outputFrameCutter.set("frame", output_frame); + return outputFrameCutter; +} +void FrameCutter::reset() { +_framecutter->reset(); +} +// END FrameCutter definitions + +// START FrameToReal definitions // check https://essentia.upf.edu/reference/std_FrameToReal.html -val EssentiaJS::FrameToReal(std::vector& input_signal, const int frameSize, const int hopSize) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoFrameToReal = factory.create("FrameToReal", "frameSize", frameSize, "hopSize", hopSize); - algoFrameToReal->input("signal").set(input_signal); - std::vector output_signal; - algoFrameToReal->output("signal").set(output_signal); - algoFrameToReal->compute(); - val outputFrameToReal(val::object()); - outputFrameToReal.set("signal", output_signal); - delete algoFrameToReal; - return outputFrameToReal; -} - +FrameToReal::FrameToReal(const int frameSize, const int hopSize) { + configure(frameSize, hopSize); +} +FrameToReal::~FrameToReal() { + delete _frametoreal; +} +void FrameToReal::configure(const int frameSize, const int hopSize) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _frametoreal = factory.create("FrameToReal", "frameSize", frameSize, "hopSize", hopSize); +} +val FrameToReal::compute(std::vector& input_signal) { + _frametoreal->input("signal").set(input_signal); + std::vector output_signal; + _frametoreal->output("signal").set(output_signal); + _frametoreal->compute(); + val outputFrameToReal(val::object()); + outputFrameToReal.set("signal", output_signal); + return outputFrameToReal; +} +void FrameToReal::reset() { +_frametoreal->reset(); +} +// END FrameToReal definitions + +// START FrequencyBands definitions // check https://essentia.upf.edu/reference/std_FrequencyBands.html -val EssentiaJS::FrequencyBands(std::vector& input_spectrum, const std::vector& frequencyBands, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoFrequencyBands = factory.create("FrequencyBands", "frequencyBands", frequencyBands, "sampleRate", sampleRate); - algoFrequencyBands->input("spectrum").set(input_spectrum); - std::vector output_bands; - algoFrequencyBands->output("bands").set(output_bands); - algoFrequencyBands->compute(); - val outputFrequencyBands(val::object()); - outputFrequencyBands.set("bands", output_bands); - delete algoFrequencyBands; - return outputFrequencyBands; -} - +FrequencyBands::FrequencyBands(const std::vector& frequencyBands, const float sampleRate) { + configure(frequencyBands, sampleRate); +} +FrequencyBands::~FrequencyBands() { + delete _frequencybands; +} +void FrequencyBands::configure(const std::vector& frequencyBands, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _frequencybands = factory.create("FrequencyBands", "frequencyBands", frequencyBands, "sampleRate", sampleRate); +} +val FrequencyBands::compute(std::vector& input_spectrum) { + _frequencybands->input("spectrum").set(input_spectrum); + std::vector output_bands; + _frequencybands->output("bands").set(output_bands); + _frequencybands->compute(); + val outputFrequencyBands(val::object()); + outputFrequencyBands.set("bands", output_bands); + return outputFrequencyBands; +} +void FrequencyBands::reset() { +_frequencybands->reset(); +} +// END FrequencyBands definitions + +// START GFCC definitions // check https://essentia.upf.edu/reference/std_GFCC.html -val EssentiaJS::GFCC(std::vector& input_spectrum, const int dctType, const float highFrequencyBound, const int inputSize, const std::string& logType, const float lowFrequencyBound, const int numberBands, const int numberCoefficients, const float sampleRate, const float silenceThreshold, const std::string& type) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoGFCC = factory.create("GFCC", "dctType", dctType, "highFrequencyBound", highFrequencyBound, "inputSize", inputSize, "logType", logType, "lowFrequencyBound", lowFrequencyBound, "numberBands", numberBands, "numberCoefficients", numberCoefficients, "sampleRate", sampleRate, "silenceThreshold", silenceThreshold, "type", type); - algoGFCC->input("spectrum").set(input_spectrum); - std::vector output_bands; - std::vector output_gfcc; - algoGFCC->output("bands").set(output_bands); - algoGFCC->output("gfcc").set(output_gfcc); - algoGFCC->compute(); - val outputGFCC(val::object()); - outputGFCC.set("bands", output_bands); - outputGFCC.set("gfcc", output_gfcc); - delete algoGFCC; - return outputGFCC; -} - +GFCC::GFCC(const int dctType, const float highFrequencyBound, const int inputSize, const std::string& logType, const float lowFrequencyBound, const int numberBands, const int numberCoefficients, const float sampleRate, const float silenceThreshold, const std::string& type) { + configure(dctType, highFrequencyBound, inputSize, logType, lowFrequencyBound, numberBands, numberCoefficients, sampleRate, silenceThreshold, type); +} +GFCC::~GFCC() { + delete _gfcc; +} +void GFCC::configure(const int dctType, const float highFrequencyBound, const int inputSize, const std::string& logType, const float lowFrequencyBound, const int numberBands, const int numberCoefficients, const float sampleRate, const float silenceThreshold, const std::string& type) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _gfcc = factory.create("GFCC", "dctType", dctType, "highFrequencyBound", highFrequencyBound, "inputSize", inputSize, "logType", logType, "lowFrequencyBound", lowFrequencyBound, "numberBands", numberBands, "numberCoefficients", numberCoefficients, "sampleRate", sampleRate, "silenceThreshold", silenceThreshold, "type", type); +} +val GFCC::compute(std::vector& input_spectrum) { + _gfcc->input("spectrum").set(input_spectrum); + std::vector output_bands; + std::vector output_gfcc; + _gfcc->output("bands").set(output_bands); + _gfcc->output("gfcc").set(output_gfcc); + _gfcc->compute(); + val outputGFCC(val::object()); + outputGFCC.set("bands", output_bands); + outputGFCC.set("gfcc", output_gfcc); + return outputGFCC; +} +void GFCC::reset() { +_gfcc->reset(); +} +// END GFCC definitions + +// START GapsDetector definitions // check https://essentia.upf.edu/reference/std_GapsDetector.html -val EssentiaJS::GapsDetector(std::vector& input_frame, const float attackTime, const int frameSize, const int hopSize, const int kernelSize, const float maximumTime, const float minimumTime, const float postpowerTime, const float prepowerThreshold, const float prepowerTime, const float releaseTime, const float sampleRate, const float silenceThreshold) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoGapsDetector = factory.create("GapsDetector", "attackTime", attackTime, "frameSize", frameSize, "hopSize", hopSize, "kernelSize", kernelSize, "maximumTime", maximumTime, "minimumTime", minimumTime, "postpowerTime", postpowerTime, "prepowerThreshold", prepowerThreshold, "prepowerTime", prepowerTime, "releaseTime", releaseTime, "sampleRate", sampleRate, "silenceThreshold", silenceThreshold); - algoGapsDetector->input("frame").set(input_frame); - std::vector output_starts; - std::vector output_ends; - algoGapsDetector->output("starts").set(output_starts); - algoGapsDetector->output("ends").set(output_ends); - algoGapsDetector->compute(); - val outputGapsDetector(val::object()); - outputGapsDetector.set("starts", output_starts); - outputGapsDetector.set("ends", output_ends); - delete algoGapsDetector; - return outputGapsDetector; -} - +GapsDetector::GapsDetector(const float attackTime, const int frameSize, const int hopSize, const int kernelSize, const float maximumTime, const float minimumTime, const float postpowerTime, const float prepowerThreshold, const float prepowerTime, const float releaseTime, const float sampleRate, const float silenceThreshold) { + configure(attackTime, frameSize, hopSize, kernelSize, maximumTime, minimumTime, postpowerTime, prepowerThreshold, prepowerTime, releaseTime, sampleRate, silenceThreshold); +} +GapsDetector::~GapsDetector() { + delete _gapsdetector; +} +void GapsDetector::configure(const float attackTime, const int frameSize, const int hopSize, const int kernelSize, const float maximumTime, const float minimumTime, const float postpowerTime, const float prepowerThreshold, const float prepowerTime, const float releaseTime, const float sampleRate, const float silenceThreshold) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _gapsdetector = factory.create("GapsDetector", "attackTime", attackTime, "frameSize", frameSize, "hopSize", hopSize, "kernelSize", kernelSize, "maximumTime", maximumTime, "minimumTime", minimumTime, "postpowerTime", postpowerTime, "prepowerThreshold", prepowerThreshold, "prepowerTime", prepowerTime, "releaseTime", releaseTime, "sampleRate", sampleRate, "silenceThreshold", silenceThreshold); +} +val GapsDetector::compute(std::vector& input_frame) { + _gapsdetector->input("frame").set(input_frame); + std::vector output_starts; + std::vector output_ends; + _gapsdetector->output("starts").set(output_starts); + _gapsdetector->output("ends").set(output_ends); + _gapsdetector->compute(); + val outputGapsDetector(val::object()); + outputGapsDetector.set("starts", output_starts); + outputGapsDetector.set("ends", output_ends); + return outputGapsDetector; +} +void GapsDetector::reset() { +_gapsdetector->reset(); +} +// END GapsDetector definitions + +// START GeometricMean definitions // check https://essentia.upf.edu/reference/std_GeometricMean.html -val EssentiaJS::GeometricMean(std::vector& input_array) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoGeometricMean = factory.create("GeometricMean"); - algoGeometricMean->input("array").set(input_array); - float output_geometricMean; - algoGeometricMean->output("geometricMean").set(output_geometricMean); - algoGeometricMean->compute(); - val outputGeometricMean(val::object()); - outputGeometricMean.set("geometricMean", output_geometricMean); - delete algoGeometricMean; - return outputGeometricMean; -} - +GeometricMean::GeometricMean() { + configure(); +} +GeometricMean::~GeometricMean() { + delete _geometricmean; +} +void GeometricMean::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _geometricmean = factory.create("GeometricMean"); +} +val GeometricMean::compute(std::vector& input_array) { + _geometricmean->input("array").set(input_array); + float output_geometricMean; + _geometricmean->output("geometricMean").set(output_geometricMean); + _geometricmean->compute(); + val outputGeometricMean(val::object()); + outputGeometricMean.set("geometricMean", output_geometricMean); + return outputGeometricMean; +} +void GeometricMean::reset() { +_geometricmean->reset(); +} +// END GeometricMean definitions + +// START HFC definitions // check https://essentia.upf.edu/reference/std_HFC.html -val EssentiaJS::HFC(std::vector& input_spectrum, const float sampleRate, const std::string& type) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoHFC = factory.create("HFC", "sampleRate", sampleRate, "type", type); - algoHFC->input("spectrum").set(input_spectrum); - float output_hfc; - algoHFC->output("hfc").set(output_hfc); - algoHFC->compute(); - val outputHFC(val::object()); - outputHFC.set("hfc", output_hfc); - delete algoHFC; - return outputHFC; -} - +HFC::HFC(const float sampleRate, const std::string& type) { + configure(sampleRate, type); +} +HFC::~HFC() { + delete _hfc; +} +void HFC::configure(const float sampleRate, const std::string& type) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _hfc = factory.create("HFC", "sampleRate", sampleRate, "type", type); +} +val HFC::compute(std::vector& input_spectrum) { + _hfc->input("spectrum").set(input_spectrum); + float output_hfc; + _hfc->output("hfc").set(output_hfc); + _hfc->compute(); + val outputHFC(val::object()); + outputHFC.set("hfc", output_hfc); + return outputHFC; +} +void HFC::reset() { +_hfc->reset(); +} +// END HFC definitions + +// START HPCP definitions // check https://essentia.upf.edu/reference/std_HPCP.html -val EssentiaJS::HPCP(std::vector& input_frequencies, std::vector& input_magnitudes, const bool bandPreset, const float bandSplitFrequency, const int harmonics, const float maxFrequency, const bool maxShifted, const float minFrequency, const bool nonLinear, const std::string& normalized, const float referenceFrequency, const float sampleRate, const int size, const std::string& weightType, const float windowSize) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoHPCP = factory.create("HPCP", "bandPreset", bandPreset, "bandSplitFrequency", bandSplitFrequency, "harmonics", harmonics, "maxFrequency", maxFrequency, "maxShifted", maxShifted, "minFrequency", minFrequency, "nonLinear", nonLinear, "normalized", normalized, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate, "size", size, "weightType", weightType, "windowSize", windowSize); - algoHPCP->input("frequencies").set(input_frequencies); - algoHPCP->input("magnitudes").set(input_magnitudes); - std::vector output_hpcp; - algoHPCP->output("hpcp").set(output_hpcp); - algoHPCP->compute(); - val outputHPCP(val::object()); - outputHPCP.set("hpcp", output_hpcp); - delete algoHPCP; - return outputHPCP; -} - +HPCP::HPCP(const bool bandPreset, const float bandSplitFrequency, const int harmonics, const float maxFrequency, const bool maxShifted, const float minFrequency, const bool nonLinear, const std::string& normalized, const float referenceFrequency, const float sampleRate, const int size, const std::string& weightType, const float windowSize) { + configure(bandPreset, bandSplitFrequency, harmonics, maxFrequency, maxShifted, minFrequency, nonLinear, normalized, referenceFrequency, sampleRate, size, weightType, windowSize); +} +HPCP::~HPCP() { + delete _hpcp; +} +void HPCP::configure(const bool bandPreset, const float bandSplitFrequency, const int harmonics, const float maxFrequency, const bool maxShifted, const float minFrequency, const bool nonLinear, const std::string& normalized, const float referenceFrequency, const float sampleRate, const int size, const std::string& weightType, const float windowSize) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _hpcp = factory.create("HPCP", "bandPreset", bandPreset, "bandSplitFrequency", bandSplitFrequency, "harmonics", harmonics, "maxFrequency", maxFrequency, "maxShifted", maxShifted, "minFrequency", minFrequency, "nonLinear", nonLinear, "normalized", normalized, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate, "size", size, "weightType", weightType, "windowSize", windowSize); +} +val HPCP::compute(std::vector& input_frequencies, std::vector& input_magnitudes) { + _hpcp->input("frequencies").set(input_frequencies); + _hpcp->input("magnitudes").set(input_magnitudes); + std::vector output_hpcp; + _hpcp->output("hpcp").set(output_hpcp); + _hpcp->compute(); + val outputHPCP(val::object()); + outputHPCP.set("hpcp", output_hpcp); + return outputHPCP; +} +void HPCP::reset() { +_hpcp->reset(); +} +// END HPCP definitions + +// START HarmonicBpm definitions // check https://essentia.upf.edu/reference/std_HarmonicBpm.html -val EssentiaJS::HarmonicBpm(std::vector& input_bpms, const int bpm, const float threshold, const float tolerance) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoHarmonicBpm = factory.create("HarmonicBpm", "bpm", bpm, "threshold", threshold, "tolerance", tolerance); - algoHarmonicBpm->input("bpms").set(input_bpms); - std::vector output_harmonicBpms; - algoHarmonicBpm->output("harmonicBpms").set(output_harmonicBpms); - algoHarmonicBpm->compute(); - val outputHarmonicBpm(val::object()); - outputHarmonicBpm.set("harmonicBpms", output_harmonicBpms); - delete algoHarmonicBpm; - return outputHarmonicBpm; -} - +HarmonicBpm::HarmonicBpm(const float bpm, const float threshold, const float tolerance) { + configure(bpm, threshold, tolerance); +} +HarmonicBpm::~HarmonicBpm() { + delete _harmonicbpm; +} +void HarmonicBpm::configure(const float bpm, const float threshold, const float tolerance) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _harmonicbpm = factory.create("HarmonicBpm", "bpm", bpm, "threshold", threshold, "tolerance", tolerance); +} +val HarmonicBpm::compute(std::vector& input_bpms) { + _harmonicbpm->input("bpms").set(input_bpms); + std::vector output_harmonicBpms; + _harmonicbpm->output("harmonicBpms").set(output_harmonicBpms); + _harmonicbpm->compute(); + val outputHarmonicBpm(val::object()); + outputHarmonicBpm.set("harmonicBpms", output_harmonicBpms); + return outputHarmonicBpm; +} +void HarmonicBpm::reset() { +_harmonicbpm->reset(); +} +// END HarmonicBpm definitions + +// START HarmonicPeaks definitions // check https://essentia.upf.edu/reference/std_HarmonicPeaks.html -val EssentiaJS::HarmonicPeaks(std::vector& input_frequencies, std::vector& input_magnitudes, float input_pitch, const int maxHarmonics, const float tolerance) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoHarmonicPeaks = factory.create("HarmonicPeaks", "maxHarmonics", maxHarmonics, "tolerance", tolerance); - algoHarmonicPeaks->input("frequencies").set(input_frequencies); - algoHarmonicPeaks->input("magnitudes").set(input_magnitudes); - algoHarmonicPeaks->input("pitch").set(input_pitch); - std::vector output_harmonicFrequencies; - std::vector output_harmonicMagnitudes; - algoHarmonicPeaks->output("harmonicFrequencies").set(output_harmonicFrequencies); - algoHarmonicPeaks->output("harmonicMagnitudes").set(output_harmonicMagnitudes); - algoHarmonicPeaks->compute(); - val outputHarmonicPeaks(val::object()); - outputHarmonicPeaks.set("harmonicFrequencies", output_harmonicFrequencies); - outputHarmonicPeaks.set("harmonicMagnitudes", output_harmonicMagnitudes); - delete algoHarmonicPeaks; - return outputHarmonicPeaks; -} - +HarmonicPeaks::HarmonicPeaks(const int maxHarmonics, const float tolerance) { + configure(maxHarmonics, tolerance); +} +HarmonicPeaks::~HarmonicPeaks() { + delete _harmonicpeaks; +} +void HarmonicPeaks::configure(const int maxHarmonics, const float tolerance) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _harmonicpeaks = factory.create("HarmonicPeaks", "maxHarmonics", maxHarmonics, "tolerance", tolerance); +} +val HarmonicPeaks::compute(std::vector& input_frequencies, std::vector& input_magnitudes, float input_pitch) { + _harmonicpeaks->input("frequencies").set(input_frequencies); + _harmonicpeaks->input("magnitudes").set(input_magnitudes); + _harmonicpeaks->input("pitch").set(input_pitch); + std::vector output_harmonicFrequencies; + std::vector output_harmonicMagnitudes; + _harmonicpeaks->output("harmonicFrequencies").set(output_harmonicFrequencies); + _harmonicpeaks->output("harmonicMagnitudes").set(output_harmonicMagnitudes); + _harmonicpeaks->compute(); + val outputHarmonicPeaks(val::object()); + outputHarmonicPeaks.set("harmonicFrequencies", output_harmonicFrequencies); + outputHarmonicPeaks.set("harmonicMagnitudes", output_harmonicMagnitudes); + return outputHarmonicPeaks; +} +void HarmonicPeaks::reset() { +_harmonicpeaks->reset(); +} +// END HarmonicPeaks definitions + +// START HighPass definitions // check https://essentia.upf.edu/reference/std_HighPass.html -val EssentiaJS::HighPass(std::vector& input_signal, const float cutoffFrequency, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoHighPass = factory.create("HighPass", "cutoffFrequency", cutoffFrequency, "sampleRate", sampleRate); - algoHighPass->input("signal").set(input_signal); - std::vector output_signal; - algoHighPass->output("signal").set(output_signal); - algoHighPass->compute(); - val outputHighPass(val::object()); - outputHighPass.set("signal", output_signal); - delete algoHighPass; - return outputHighPass; -} - +HighPass::HighPass(const float cutoffFrequency, const float sampleRate) { + configure(cutoffFrequency, sampleRate); +} +HighPass::~HighPass() { + delete _highpass; +} +void HighPass::configure(const float cutoffFrequency, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _highpass = factory.create("HighPass", "cutoffFrequency", cutoffFrequency, "sampleRate", sampleRate); +} +val HighPass::compute(std::vector& input_signal) { + _highpass->input("signal").set(input_signal); + std::vector output_signal; + _highpass->output("signal").set(output_signal); + _highpass->compute(); + val outputHighPass(val::object()); + outputHighPass.set("signal", output_signal); + return outputHighPass; +} +void HighPass::reset() { +_highpass->reset(); +} +// END HighPass definitions + +// START HighResolutionFeatures definitions // check https://essentia.upf.edu/reference/std_HighResolutionFeatures.html -val EssentiaJS::HighResolutionFeatures(std::vector& input_hpcp, const int maxPeaks) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoHighResolutionFeatures = factory.create("HighResolutionFeatures", "maxPeaks", maxPeaks); - algoHighResolutionFeatures->input("hpcp").set(input_hpcp); - float output_equalTemperedDeviation; - float output_nonTemperedEnergyRatio; - float output_nonTemperedPeaksEnergyRatio; - algoHighResolutionFeatures->output("equalTemperedDeviation").set(output_equalTemperedDeviation); - algoHighResolutionFeatures->output("nonTemperedEnergyRatio").set(output_nonTemperedEnergyRatio); - algoHighResolutionFeatures->output("nonTemperedPeaksEnergyRatio").set(output_nonTemperedPeaksEnergyRatio); - algoHighResolutionFeatures->compute(); - val outputHighResolutionFeatures(val::object()); - outputHighResolutionFeatures.set("equalTemperedDeviation", output_equalTemperedDeviation); - outputHighResolutionFeatures.set("nonTemperedEnergyRatio", output_nonTemperedEnergyRatio); - outputHighResolutionFeatures.set("nonTemperedPeaksEnergyRatio", output_nonTemperedPeaksEnergyRatio); - delete algoHighResolutionFeatures; - return outputHighResolutionFeatures; -} - +HighResolutionFeatures::HighResolutionFeatures(const int maxPeaks) { + configure(maxPeaks); +} +HighResolutionFeatures::~HighResolutionFeatures() { + delete _highresolutionfeatures; +} +void HighResolutionFeatures::configure(const int maxPeaks) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _highresolutionfeatures = factory.create("HighResolutionFeatures", "maxPeaks", maxPeaks); +} +val HighResolutionFeatures::compute(std::vector& input_hpcp) { + _highresolutionfeatures->input("hpcp").set(input_hpcp); + float output_equalTemperedDeviation; + float output_nonTemperedEnergyRatio; + float output_nonTemperedPeaksEnergyRatio; + _highresolutionfeatures->output("equalTemperedDeviation").set(output_equalTemperedDeviation); + _highresolutionfeatures->output("nonTemperedEnergyRatio").set(output_nonTemperedEnergyRatio); + _highresolutionfeatures->output("nonTemperedPeaksEnergyRatio").set(output_nonTemperedPeaksEnergyRatio); + _highresolutionfeatures->compute(); + val outputHighResolutionFeatures(val::object()); + outputHighResolutionFeatures.set("equalTemperedDeviation", output_equalTemperedDeviation); + outputHighResolutionFeatures.set("nonTemperedEnergyRatio", output_nonTemperedEnergyRatio); + outputHighResolutionFeatures.set("nonTemperedPeaksEnergyRatio", output_nonTemperedPeaksEnergyRatio); + return outputHighResolutionFeatures; +} +void HighResolutionFeatures::reset() { +_highresolutionfeatures->reset(); +} +// END HighResolutionFeatures definitions + +// START Histogram definitions // check https://essentia.upf.edu/reference/std_Histogram.html -val EssentiaJS::Histogram(std::vector& input_array, const float maxValue, const float minValue, const std::string& normalize, const int numberBins) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoHistogram = factory.create("Histogram", "maxValue", maxValue, "minValue", minValue, "normalize", normalize, "numberBins", numberBins); - algoHistogram->input("array").set(input_array); - std::vector output_histogram; - std::vector output_binEdges; - algoHistogram->output("histogram").set(output_histogram); - algoHistogram->output("binEdges").set(output_binEdges); - algoHistogram->compute(); - val outputHistogram(val::object()); - outputHistogram.set("histogram", output_histogram); - outputHistogram.set("binEdges", output_binEdges); - delete algoHistogram; - return outputHistogram; -} - +Histogram::Histogram(const float maxValue, const float minValue, const std::string& normalize, const int numberBins) { + configure(maxValue, minValue, normalize, numberBins); +} +Histogram::~Histogram() { + delete _histogram; +} +void Histogram::configure(const float maxValue, const float minValue, const std::string& normalize, const int numberBins) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _histogram = factory.create("Histogram", "maxValue", maxValue, "minValue", minValue, "normalize", normalize, "numberBins", numberBins); +} +val Histogram::compute(std::vector& input_array) { + _histogram->input("array").set(input_array); + std::vector output_histogram; + std::vector output_binEdges; + _histogram->output("histogram").set(output_histogram); + _histogram->output("binEdges").set(output_binEdges); + _histogram->compute(); + val outputHistogram(val::object()); + outputHistogram.set("histogram", output_histogram); + outputHistogram.set("binEdges", output_binEdges); + return outputHistogram; +} +void Histogram::reset() { +_histogram->reset(); +} +// END Histogram definitions + +// START HprModelAnal definitions // check https://essentia.upf.edu/reference/std_HprModelAnal.html -val EssentiaJS::HprModelAnal(std::vector& input_frame, float input_pitch, const int fftSize, const int freqDevOffset, const float freqDevSlope, const float harmDevSlope, const int hopSize, const float magnitudeThreshold, const float maxFrequency, const int maxPeaks, const int maxnSines, const float minFrequency, const int nHarmonics, const std::string& orderBy, const float sampleRate, const float stocf) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoHprModelAnal = factory.create("HprModelAnal", "fftSize", fftSize, "freqDevOffset", freqDevOffset, "freqDevSlope", freqDevSlope, "harmDevSlope", harmDevSlope, "hopSize", hopSize, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "maxPeaks", maxPeaks, "maxnSines", maxnSines, "minFrequency", minFrequency, "nHarmonics", nHarmonics, "orderBy", orderBy, "sampleRate", sampleRate, "stocf", stocf); - algoHprModelAnal->input("frame").set(input_frame); - algoHprModelAnal->input("pitch").set(input_pitch); - std::vector output_frequencies; - std::vector output_magnitudes; - std::vector output_phases; - std::vector output_res; - algoHprModelAnal->output("frequencies").set(output_frequencies); - algoHprModelAnal->output("magnitudes").set(output_magnitudes); - algoHprModelAnal->output("phases").set(output_phases); - algoHprModelAnal->output("res").set(output_res); - algoHprModelAnal->compute(); - val outputHprModelAnal(val::object()); - outputHprModelAnal.set("frequencies", output_frequencies); - outputHprModelAnal.set("magnitudes", output_magnitudes); - outputHprModelAnal.set("phases", output_phases); - outputHprModelAnal.set("res", output_res); - delete algoHprModelAnal; - return outputHprModelAnal; -} - +HprModelAnal::HprModelAnal(const int fftSize, const int freqDevOffset, const float freqDevSlope, const float harmDevSlope, const int hopSize, const float magnitudeThreshold, const float maxFrequency, const int maxPeaks, const int maxnSines, const float minFrequency, const int nHarmonics, const std::string& orderBy, const float sampleRate, const float stocf) { + configure(fftSize, freqDevOffset, freqDevSlope, harmDevSlope, hopSize, magnitudeThreshold, maxFrequency, maxPeaks, maxnSines, minFrequency, nHarmonics, orderBy, sampleRate, stocf); +} +HprModelAnal::~HprModelAnal() { + delete _hprmodelanal; +} +void HprModelAnal::configure(const int fftSize, const int freqDevOffset, const float freqDevSlope, const float harmDevSlope, const int hopSize, const float magnitudeThreshold, const float maxFrequency, const int maxPeaks, const int maxnSines, const float minFrequency, const int nHarmonics, const std::string& orderBy, const float sampleRate, const float stocf) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _hprmodelanal = factory.create("HprModelAnal", "fftSize", fftSize, "freqDevOffset", freqDevOffset, "freqDevSlope", freqDevSlope, "harmDevSlope", harmDevSlope, "hopSize", hopSize, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "maxPeaks", maxPeaks, "maxnSines", maxnSines, "minFrequency", minFrequency, "nHarmonics", nHarmonics, "orderBy", orderBy, "sampleRate", sampleRate, "stocf", stocf); +} +val HprModelAnal::compute(std::vector& input_frame, float input_pitch) { + _hprmodelanal->input("frame").set(input_frame); + _hprmodelanal->input("pitch").set(input_pitch); + std::vector output_frequencies; + std::vector output_magnitudes; + std::vector output_phases; + std::vector output_res; + _hprmodelanal->output("frequencies").set(output_frequencies); + _hprmodelanal->output("magnitudes").set(output_magnitudes); + _hprmodelanal->output("phases").set(output_phases); + _hprmodelanal->output("res").set(output_res); + _hprmodelanal->compute(); + val outputHprModelAnal(val::object()); + outputHprModelAnal.set("frequencies", output_frequencies); + outputHprModelAnal.set("magnitudes", output_magnitudes); + outputHprModelAnal.set("phases", output_phases); + outputHprModelAnal.set("res", output_res); + return outputHprModelAnal; +} +void HprModelAnal::reset() { +_hprmodelanal->reset(); +} +// END HprModelAnal definitions + +// START HpsModelAnal definitions // check https://essentia.upf.edu/reference/std_HpsModelAnal.html -val EssentiaJS::HpsModelAnal(std::vector& input_frame, float input_pitch, const int fftSize, const int freqDevOffset, const float freqDevSlope, const float harmDevSlope, const int hopSize, const float magnitudeThreshold, const float maxFrequency, const int maxPeaks, const int maxnSines, const float minFrequency, const int nHarmonics, const std::string& orderBy, const float sampleRate, const float stocf) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoHpsModelAnal = factory.create("HpsModelAnal", "fftSize", fftSize, "freqDevOffset", freqDevOffset, "freqDevSlope", freqDevSlope, "harmDevSlope", harmDevSlope, "hopSize", hopSize, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "maxPeaks", maxPeaks, "maxnSines", maxnSines, "minFrequency", minFrequency, "nHarmonics", nHarmonics, "orderBy", orderBy, "sampleRate", sampleRate, "stocf", stocf); - algoHpsModelAnal->input("frame").set(input_frame); - algoHpsModelAnal->input("pitch").set(input_pitch); - std::vector output_frequencies; - std::vector output_magnitudes; - std::vector output_phases; - std::vector output_stocenv; - algoHpsModelAnal->output("frequencies").set(output_frequencies); - algoHpsModelAnal->output("magnitudes").set(output_magnitudes); - algoHpsModelAnal->output("phases").set(output_phases); - algoHpsModelAnal->output("stocenv").set(output_stocenv); - algoHpsModelAnal->compute(); - val outputHpsModelAnal(val::object()); - outputHpsModelAnal.set("frequencies", output_frequencies); - outputHpsModelAnal.set("magnitudes", output_magnitudes); - outputHpsModelAnal.set("phases", output_phases); - outputHpsModelAnal.set("stocenv", output_stocenv); - delete algoHpsModelAnal; - return outputHpsModelAnal; -} - +HpsModelAnal::HpsModelAnal(const int fftSize, const int freqDevOffset, const float freqDevSlope, const float harmDevSlope, const int hopSize, const float magnitudeThreshold, const float maxFrequency, const int maxPeaks, const int maxnSines, const float minFrequency, const int nHarmonics, const std::string& orderBy, const float sampleRate, const float stocf) { + configure(fftSize, freqDevOffset, freqDevSlope, harmDevSlope, hopSize, magnitudeThreshold, maxFrequency, maxPeaks, maxnSines, minFrequency, nHarmonics, orderBy, sampleRate, stocf); +} +HpsModelAnal::~HpsModelAnal() { + delete _hpsmodelanal; +} +void HpsModelAnal::configure(const int fftSize, const int freqDevOffset, const float freqDevSlope, const float harmDevSlope, const int hopSize, const float magnitudeThreshold, const float maxFrequency, const int maxPeaks, const int maxnSines, const float minFrequency, const int nHarmonics, const std::string& orderBy, const float sampleRate, const float stocf) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _hpsmodelanal = factory.create("HpsModelAnal", "fftSize", fftSize, "freqDevOffset", freqDevOffset, "freqDevSlope", freqDevSlope, "harmDevSlope", harmDevSlope, "hopSize", hopSize, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "maxPeaks", maxPeaks, "maxnSines", maxnSines, "minFrequency", minFrequency, "nHarmonics", nHarmonics, "orderBy", orderBy, "sampleRate", sampleRate, "stocf", stocf); +} +val HpsModelAnal::compute(std::vector& input_frame, float input_pitch) { + _hpsmodelanal->input("frame").set(input_frame); + _hpsmodelanal->input("pitch").set(input_pitch); + std::vector output_frequencies; + std::vector output_magnitudes; + std::vector output_phases; + std::vector output_stocenv; + _hpsmodelanal->output("frequencies").set(output_frequencies); + _hpsmodelanal->output("magnitudes").set(output_magnitudes); + _hpsmodelanal->output("phases").set(output_phases); + _hpsmodelanal->output("stocenv").set(output_stocenv); + _hpsmodelanal->compute(); + val outputHpsModelAnal(val::object()); + outputHpsModelAnal.set("frequencies", output_frequencies); + outputHpsModelAnal.set("magnitudes", output_magnitudes); + outputHpsModelAnal.set("phases", output_phases); + outputHpsModelAnal.set("stocenv", output_stocenv); + return outputHpsModelAnal; +} +void HpsModelAnal::reset() { +_hpsmodelanal->reset(); +} +// END HpsModelAnal definitions + +// START IDCT definitions // check https://essentia.upf.edu/reference/std_IDCT.html -val EssentiaJS::IDCT(std::vector& input_dct, const int dctType, const int inputSize, const int liftering, const int outputSize) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoIDCT = factory.create("IDCT", "dctType", dctType, "inputSize", inputSize, "liftering", liftering, "outputSize", outputSize); - algoIDCT->input("dct").set(input_dct); - std::vector output_idct; - algoIDCT->output("idct").set(output_idct); - algoIDCT->compute(); - val outputIDCT(val::object()); - outputIDCT.set("idct", output_idct); - delete algoIDCT; - return outputIDCT; -} - +IDCT::IDCT(const int dctType, const int inputSize, const int liftering, const int outputSize) { + configure(dctType, inputSize, liftering, outputSize); +} +IDCT::~IDCT() { + delete _idct; +} +void IDCT::configure(const int dctType, const int inputSize, const int liftering, const int outputSize) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _idct = factory.create("IDCT", "dctType", dctType, "inputSize", inputSize, "liftering", liftering, "outputSize", outputSize); +} +val IDCT::compute(std::vector& input_dct) { + _idct->input("dct").set(input_dct); + std::vector output_idct; + _idct->output("idct").set(output_idct); + _idct->compute(); + val outputIDCT(val::object()); + outputIDCT.set("idct", output_idct); + return outputIDCT; +} +void IDCT::reset() { +_idct->reset(); +} +// END IDCT definitions + +// START IIR definitions // check https://essentia.upf.edu/reference/std_IIR.html -val EssentiaJS::IIR(std::vector& input_signal, const std::vector& denominator, const std::vector& numerator) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoIIR = factory.create("IIR", "denominator", denominator, "numerator", numerator); - algoIIR->input("signal").set(input_signal); - std::vector output_signal; - algoIIR->output("signal").set(output_signal); - algoIIR->compute(); - val outputIIR(val::object()); - outputIIR.set("signal", output_signal); - delete algoIIR; - return outputIIR; -} - +IIR::IIR(const std::vector& denominator, const std::vector& numerator) { + configure(denominator, numerator); +} +IIR::~IIR() { + delete _iir; +} +void IIR::configure(const std::vector& denominator, const std::vector& numerator) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _iir = factory.create("IIR", "denominator", denominator, "numerator", numerator); +} +val IIR::compute(std::vector& input_signal) { + _iir->input("signal").set(input_signal); + std::vector output_signal; + _iir->output("signal").set(output_signal); + _iir->compute(); + val outputIIR(val::object()); + outputIIR.set("signal", output_signal); + return outputIIR; +} +void IIR::reset() { +_iir->reset(); +} +// END IIR definitions + +// START Inharmonicity definitions // check https://essentia.upf.edu/reference/std_Inharmonicity.html -val EssentiaJS::Inharmonicity(std::vector& input_frequencies, std::vector& input_magnitudes) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoInharmonicity = factory.create("Inharmonicity"); - algoInharmonicity->input("frequencies").set(input_frequencies); - algoInharmonicity->input("magnitudes").set(input_magnitudes); - float output_inharmonicity; - algoInharmonicity->output("inharmonicity").set(output_inharmonicity); - algoInharmonicity->compute(); - val outputInharmonicity(val::object()); - outputInharmonicity.set("inharmonicity", output_inharmonicity); - delete algoInharmonicity; - return outputInharmonicity; -} - +Inharmonicity::Inharmonicity() { + configure(); +} +Inharmonicity::~Inharmonicity() { + delete _inharmonicity; +} +void Inharmonicity::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _inharmonicity = factory.create("Inharmonicity"); +} +val Inharmonicity::compute(std::vector& input_frequencies, std::vector& input_magnitudes) { + _inharmonicity->input("frequencies").set(input_frequencies); + _inharmonicity->input("magnitudes").set(input_magnitudes); + float output_inharmonicity; + _inharmonicity->output("inharmonicity").set(output_inharmonicity); + _inharmonicity->compute(); + val outputInharmonicity(val::object()); + outputInharmonicity.set("inharmonicity", output_inharmonicity); + return outputInharmonicity; +} +void Inharmonicity::reset() { +_inharmonicity->reset(); +} +// END Inharmonicity definitions + +// START InstantPower definitions // check https://essentia.upf.edu/reference/std_InstantPower.html -val EssentiaJS::InstantPower(std::vector& input_array) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoInstantPower = factory.create("InstantPower"); - algoInstantPower->input("array").set(input_array); - float output_power; - algoInstantPower->output("power").set(output_power); - algoInstantPower->compute(); - val outputInstantPower(val::object()); - outputInstantPower.set("power", output_power); - delete algoInstantPower; - return outputInstantPower; -} - +InstantPower::InstantPower() { + configure(); +} +InstantPower::~InstantPower() { + delete _instantpower; +} +void InstantPower::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _instantpower = factory.create("InstantPower"); +} +val InstantPower::compute(std::vector& input_array) { + _instantpower->input("array").set(input_array); + float output_power; + _instantpower->output("power").set(output_power); + _instantpower->compute(); + val outputInstantPower(val::object()); + outputInstantPower.set("power", output_power); + return outputInstantPower; +} +void InstantPower::reset() { +_instantpower->reset(); +} +// END InstantPower definitions + +// START Intensity definitions // check https://essentia.upf.edu/reference/std_Intensity.html -val EssentiaJS::Intensity(std::vector& input_signal, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoIntensity = factory.create("Intensity", "sampleRate", sampleRate); - algoIntensity->input("signal").set(input_signal); - int output_intensity; - algoIntensity->output("intensity").set(output_intensity); - algoIntensity->compute(); - val outputIntensity(val::object()); - outputIntensity.set("intensity", output_intensity); - delete algoIntensity; - return outputIntensity; -} - +Intensity::Intensity(const float sampleRate) { + configure(sampleRate); +} +Intensity::~Intensity() { + delete _intensity; +} +void Intensity::configure(const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _intensity = factory.create("Intensity", "sampleRate", sampleRate); +} +val Intensity::compute(std::vector& input_signal) { + _intensity->input("signal").set(input_signal); + int output_intensity; + _intensity->output("intensity").set(output_intensity); + _intensity->compute(); + val outputIntensity(val::object()); + outputIntensity.set("intensity", output_intensity); + return outputIntensity; +} +void Intensity::reset() { +_intensity->reset(); +} +// END Intensity definitions + +// START Key definitions // check https://essentia.upf.edu/reference/std_Key.html -val EssentiaJS::Key(std::vector& input_pcp, const int numHarmonics, const int pcpSize, const std::string& profileType, const float slope, const bool useMajMin, const bool usePolyphony, const bool useThreeChords) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoKey = factory.create("Key", "numHarmonics", numHarmonics, "pcpSize", pcpSize, "profileType", profileType, "slope", slope, "useMajMin", useMajMin, "usePolyphony", usePolyphony, "useThreeChords", useThreeChords); - algoKey->input("pcp").set(input_pcp); - std::string output_key; - std::string output_scale; - float output_strength; - float output_firstToSecondRelativeStrength; - algoKey->output("key").set(output_key); - algoKey->output("scale").set(output_scale); - algoKey->output("strength").set(output_strength); - algoKey->output("firstToSecondRelativeStrength").set(output_firstToSecondRelativeStrength); - algoKey->compute(); - val outputKey(val::object()); - outputKey.set("key", output_key); - outputKey.set("scale", output_scale); - outputKey.set("strength", output_strength); - outputKey.set("firstToSecondRelativeStrength", output_firstToSecondRelativeStrength); - delete algoKey; - return outputKey; -} - +Key::Key(const int numHarmonics, const int pcpSize, const std::string& profileType, const float slope, const bool useMajMin, const bool usePolyphony, const bool useThreeChords) { + configure(numHarmonics, pcpSize, profileType, slope, useMajMin, usePolyphony, useThreeChords); +} +Key::~Key() { + delete _key; +} +void Key::configure(const int numHarmonics, const int pcpSize, const std::string& profileType, const float slope, const bool useMajMin, const bool usePolyphony, const bool useThreeChords) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _key = factory.create("Key", "numHarmonics", numHarmonics, "pcpSize", pcpSize, "profileType", profileType, "slope", slope, "useMajMin", useMajMin, "usePolyphony", usePolyphony, "useThreeChords", useThreeChords); +} +val Key::compute(std::vector& input_pcp) { + _key->input("pcp").set(input_pcp); + std::string output_key; + std::string output_scale; + float output_strength; + float output_firstToSecondRelativeStrength; + _key->output("key").set(output_key); + _key->output("scale").set(output_scale); + _key->output("strength").set(output_strength); + _key->output("firstToSecondRelativeStrength").set(output_firstToSecondRelativeStrength); + _key->compute(); + val outputKey(val::object()); + outputKey.set("key", output_key); + outputKey.set("scale", output_scale); + outputKey.set("strength", output_strength); + outputKey.set("firstToSecondRelativeStrength", output_firstToSecondRelativeStrength); + return outputKey; +} +void Key::reset() { +_key->reset(); +} +// END Key definitions + +// START KeyExtractor definitions // check https://essentia.upf.edu/reference/std_KeyExtractor.html -val EssentiaJS::KeyExtractor(std::vector& input_audio, const bool averageDetuningCorrection, const int frameSize, const int hopSize, const int hpcpSize, const float maxFrequency, const int maximumSpectralPeaks, const float minFrequency, const float pcpThreshold, const std::string& profileType, const float sampleRate, const float spectralPeaksThreshold, const float tuningFrequency, const std::string& weightType, const std::string& windowType) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoKeyExtractor = factory.create("KeyExtractor", "averageDetuningCorrection", averageDetuningCorrection, "frameSize", frameSize, "hopSize", hopSize, "hpcpSize", hpcpSize, "maxFrequency", maxFrequency, "maximumSpectralPeaks", maximumSpectralPeaks, "minFrequency", minFrequency, "pcpThreshold", pcpThreshold, "profileType", profileType, "sampleRate", sampleRate, "spectralPeaksThreshold", spectralPeaksThreshold, "tuningFrequency", tuningFrequency, "weightType", weightType, "windowType", windowType); - algoKeyExtractor->input("audio").set(input_audio); - std::string output_key; - std::string output_scale; - float output_strength; - algoKeyExtractor->output("key").set(output_key); - algoKeyExtractor->output("scale").set(output_scale); - algoKeyExtractor->output("strength").set(output_strength); - algoKeyExtractor->compute(); - val outputKeyExtractor(val::object()); - outputKeyExtractor.set("key", output_key); - outputKeyExtractor.set("scale", output_scale); - outputKeyExtractor.set("strength", output_strength); - delete algoKeyExtractor; - return outputKeyExtractor; -} - +KeyExtractor::KeyExtractor(const bool averageDetuningCorrection, const int frameSize, const int hopSize, const int hpcpSize, const float maxFrequency, const int maximumSpectralPeaks, const float minFrequency, const float pcpThreshold, const std::string& profileType, const float sampleRate, const float spectralPeaksThreshold, const float tuningFrequency, const std::string& weightType, const std::string& windowType) { + configure(averageDetuningCorrection, frameSize, hopSize, hpcpSize, maxFrequency, maximumSpectralPeaks, minFrequency, pcpThreshold, profileType, sampleRate, spectralPeaksThreshold, tuningFrequency, weightType, windowType); +} +KeyExtractor::~KeyExtractor() { + delete _keyextractor; +} +void KeyExtractor::configure(const bool averageDetuningCorrection, const int frameSize, const int hopSize, const int hpcpSize, const float maxFrequency, const int maximumSpectralPeaks, const float minFrequency, const float pcpThreshold, const std::string& profileType, const float sampleRate, const float spectralPeaksThreshold, const float tuningFrequency, const std::string& weightType, const std::string& windowType) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _keyextractor = factory.create("KeyExtractor", "averageDetuningCorrection", averageDetuningCorrection, "frameSize", frameSize, "hopSize", hopSize, "hpcpSize", hpcpSize, "maxFrequency", maxFrequency, "maximumSpectralPeaks", maximumSpectralPeaks, "minFrequency", minFrequency, "pcpThreshold", pcpThreshold, "profileType", profileType, "sampleRate", sampleRate, "spectralPeaksThreshold", spectralPeaksThreshold, "tuningFrequency", tuningFrequency, "weightType", weightType, "windowType", windowType); +} +val KeyExtractor::compute(std::vector& input_audio) { + _keyextractor->input("audio").set(input_audio); + std::string output_key; + std::string output_scale; + float output_strength; + _keyextractor->output("key").set(output_key); + _keyextractor->output("scale").set(output_scale); + _keyextractor->output("strength").set(output_strength); + _keyextractor->compute(); + val outputKeyExtractor(val::object()); + outputKeyExtractor.set("key", output_key); + outputKeyExtractor.set("scale", output_scale); + outputKeyExtractor.set("strength", output_strength); + return outputKeyExtractor; +} +void KeyExtractor::reset() { +_keyextractor->reset(); +} +// END KeyExtractor definitions + +// START LPC definitions // check https://essentia.upf.edu/reference/std_LPC.html -val EssentiaJS::LPC(std::vector& input_frame, const int order, const float sampleRate, const std::string& type) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoLPC = factory.create("LPC", "order", order, "sampleRate", sampleRate, "type", type); - algoLPC->input("frame").set(input_frame); - std::vector output_lpc; - std::vector output_reflection; - algoLPC->output("lpc").set(output_lpc); - algoLPC->output("reflection").set(output_reflection); - algoLPC->compute(); - val outputLPC(val::object()); - outputLPC.set("lpc", output_lpc); - outputLPC.set("reflection", output_reflection); - delete algoLPC; - return outputLPC; -} - +LPC::LPC(const int order, const float sampleRate, const std::string& type) { + configure(order, sampleRate, type); +} +LPC::~LPC() { + delete _lpc; +} +void LPC::configure(const int order, const float sampleRate, const std::string& type) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _lpc = factory.create("LPC", "order", order, "sampleRate", sampleRate, "type", type); +} +val LPC::compute(std::vector& input_frame) { + _lpc->input("frame").set(input_frame); + std::vector output_lpc; + std::vector output_reflection; + _lpc->output("lpc").set(output_lpc); + _lpc->output("reflection").set(output_reflection); + _lpc->compute(); + val outputLPC(val::object()); + outputLPC.set("lpc", output_lpc); + outputLPC.set("reflection", output_reflection); + return outputLPC; +} +void LPC::reset() { +_lpc->reset(); +} +// END LPC definitions + +// START Larm definitions // check https://essentia.upf.edu/reference/std_Larm.html -val EssentiaJS::Larm(std::vector& input_signal, const float attackTime, const float power, const float releaseTime, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoLarm = factory.create("Larm", "attackTime", attackTime, "power", power, "releaseTime", releaseTime, "sampleRate", sampleRate); - algoLarm->input("signal").set(input_signal); - float output_larm; - algoLarm->output("larm").set(output_larm); - algoLarm->compute(); - val outputLarm(val::object()); - outputLarm.set("larm", output_larm); - delete algoLarm; - return outputLarm; -} - +Larm::Larm(const float attackTime, const float power, const float releaseTime, const float sampleRate) { + configure(attackTime, power, releaseTime, sampleRate); +} +Larm::~Larm() { + delete _larm; +} +void Larm::configure(const float attackTime, const float power, const float releaseTime, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _larm = factory.create("Larm", "attackTime", attackTime, "power", power, "releaseTime", releaseTime, "sampleRate", sampleRate); +} +val Larm::compute(std::vector& input_signal) { + _larm->input("signal").set(input_signal); + float output_larm; + _larm->output("larm").set(output_larm); + _larm->compute(); + val outputLarm(val::object()); + outputLarm.set("larm", output_larm); + return outputLarm; +} +void Larm::reset() { +_larm->reset(); +} +// END Larm definitions + +// START Leq definitions // check https://essentia.upf.edu/reference/std_Leq.html -val EssentiaJS::Leq(std::vector& input_signal) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoLeq = factory.create("Leq"); - algoLeq->input("signal").set(input_signal); - float output_leq; - algoLeq->output("leq").set(output_leq); - algoLeq->compute(); - val outputLeq(val::object()); - outputLeq.set("leq", output_leq); - delete algoLeq; - return outputLeq; -} - +Leq::Leq() { + configure(); +} +Leq::~Leq() { + delete _leq; +} +void Leq::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _leq = factory.create("Leq"); +} +val Leq::compute(std::vector& input_signal) { + _leq->input("signal").set(input_signal); + float output_leq; + _leq->output("leq").set(output_leq); + _leq->compute(); + val outputLeq(val::object()); + outputLeq.set("leq", output_leq); + return outputLeq; +} +void Leq::reset() { +_leq->reset(); +} +// END Leq definitions + +// START LevelExtractor definitions // check https://essentia.upf.edu/reference/std_LevelExtractor.html -val EssentiaJS::LevelExtractor(std::vector& input_signal, const int frameSize, const int hopSize) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoLevelExtractor = factory.create("LevelExtractor", "frameSize", frameSize, "hopSize", hopSize); - algoLevelExtractor->input("signal").set(input_signal); - std::vector output_loudness; - algoLevelExtractor->output("loudness").set(output_loudness); - algoLevelExtractor->compute(); - val outputLevelExtractor(val::object()); - outputLevelExtractor.set("loudness", output_loudness); - delete algoLevelExtractor; - return outputLevelExtractor; -} - +LevelExtractor::LevelExtractor(const int frameSize, const int hopSize) { + configure(frameSize, hopSize); +} +LevelExtractor::~LevelExtractor() { + delete _levelextractor; +} +void LevelExtractor::configure(const int frameSize, const int hopSize) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _levelextractor = factory.create("LevelExtractor", "frameSize", frameSize, "hopSize", hopSize); +} +val LevelExtractor::compute(std::vector& input_signal) { + _levelextractor->input("signal").set(input_signal); + std::vector output_loudness; + _levelextractor->output("loudness").set(output_loudness); + _levelextractor->compute(); + val outputLevelExtractor(val::object()); + outputLevelExtractor.set("loudness", output_loudness); + return outputLevelExtractor; +} +void LevelExtractor::reset() { +_levelextractor->reset(); +} +// END LevelExtractor definitions + +// START LogAttackTime definitions // check https://essentia.upf.edu/reference/std_LogAttackTime.html -val EssentiaJS::LogAttackTime(std::vector& input_signal, const float sampleRate, const float startAttackThreshold, const float stopAttackThreshold) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoLogAttackTime = factory.create("LogAttackTime", "sampleRate", sampleRate, "startAttackThreshold", startAttackThreshold, "stopAttackThreshold", stopAttackThreshold); - algoLogAttackTime->input("signal").set(input_signal); - float output_logAttackTime; - float output_attackStart; - float output_attackStop; - algoLogAttackTime->output("logAttackTime").set(output_logAttackTime); - algoLogAttackTime->output("attackStart").set(output_attackStart); - algoLogAttackTime->output("attackStop").set(output_attackStop); - algoLogAttackTime->compute(); - val outputLogAttackTime(val::object()); - outputLogAttackTime.set("logAttackTime", output_logAttackTime); - outputLogAttackTime.set("attackStart", output_attackStart); - outputLogAttackTime.set("attackStop", output_attackStop); - delete algoLogAttackTime; - return outputLogAttackTime; -} - +LogAttackTime::LogAttackTime(const float sampleRate, const float startAttackThreshold, const float stopAttackThreshold) { + configure(sampleRate, startAttackThreshold, stopAttackThreshold); +} +LogAttackTime::~LogAttackTime() { + delete _logattacktime; +} +void LogAttackTime::configure(const float sampleRate, const float startAttackThreshold, const float stopAttackThreshold) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _logattacktime = factory.create("LogAttackTime", "sampleRate", sampleRate, "startAttackThreshold", startAttackThreshold, "stopAttackThreshold", stopAttackThreshold); +} +val LogAttackTime::compute(std::vector& input_signal) { + _logattacktime->input("signal").set(input_signal); + float output_logAttackTime; + float output_attackStart; + float output_attackStop; + _logattacktime->output("logAttackTime").set(output_logAttackTime); + _logattacktime->output("attackStart").set(output_attackStart); + _logattacktime->output("attackStop").set(output_attackStop); + _logattacktime->compute(); + val outputLogAttackTime(val::object()); + outputLogAttackTime.set("logAttackTime", output_logAttackTime); + outputLogAttackTime.set("attackStart", output_attackStart); + outputLogAttackTime.set("attackStop", output_attackStop); + return outputLogAttackTime; +} +void LogAttackTime::reset() { +_logattacktime->reset(); +} +// END LogAttackTime definitions + +// START LogSpectrum definitions // check https://essentia.upf.edu/reference/std_LogSpectrum.html -val EssentiaJS::LogSpectrum(std::vector& input_spectrum, const float binsPerSemitone, const int frameSize, const float rollOn, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoLogSpectrum = factory.create("LogSpectrum", "binsPerSemitone", binsPerSemitone, "frameSize", frameSize, "rollOn", rollOn, "sampleRate", sampleRate); - algoLogSpectrum->input("spectrum").set(input_spectrum); - std::vector output_logFreqSpectrum; - std::vector output_meanTuning; - float output_localTuning; - algoLogSpectrum->output("logFreqSpectrum").set(output_logFreqSpectrum); - algoLogSpectrum->output("meanTuning").set(output_meanTuning); - algoLogSpectrum->output("localTuning").set(output_localTuning); - algoLogSpectrum->compute(); - val outputLogSpectrum(val::object()); - outputLogSpectrum.set("logFreqSpectrum", output_logFreqSpectrum); - outputLogSpectrum.set("meanTuning", output_meanTuning); - outputLogSpectrum.set("localTuning", output_localTuning); - delete algoLogSpectrum; - return outputLogSpectrum; -} - +LogSpectrum::LogSpectrum(const float binsPerSemitone, const int frameSize, const int nOctave, const float rollOn, const float sampleRate) { + configure(binsPerSemitone, frameSize, nOctave, rollOn, sampleRate); +} +LogSpectrum::~LogSpectrum() { + delete _logspectrum; +} +void LogSpectrum::configure(const float binsPerSemitone, const int frameSize, const int nOctave, const float rollOn, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _logspectrum = factory.create("LogSpectrum", "binsPerSemitone", binsPerSemitone, "frameSize", frameSize, "nOctave", nOctave, "rollOn", rollOn, "sampleRate", sampleRate); +} +val LogSpectrum::compute(std::vector& input_spectrum) { + _logspectrum->input("spectrum").set(input_spectrum); + std::vector output_logFreqSpectrum; + std::vector output_meanTuning; + float output_localTuning; + _logspectrum->output("logFreqSpectrum").set(output_logFreqSpectrum); + _logspectrum->output("meanTuning").set(output_meanTuning); + _logspectrum->output("localTuning").set(output_localTuning); + _logspectrum->compute(); + val outputLogSpectrum(val::object()); + outputLogSpectrum.set("logFreqSpectrum", output_logFreqSpectrum); + outputLogSpectrum.set("meanTuning", output_meanTuning); + outputLogSpectrum.set("localTuning", output_localTuning); + return outputLogSpectrum; +} +void LogSpectrum::reset() { +_logspectrum->reset(); +} +// END LogSpectrum definitions + +// START LoopBpmConfidence definitions // check https://essentia.upf.edu/reference/std_LoopBpmConfidence.html -val EssentiaJS::LoopBpmConfidence(std::vector& input_signal, float input_bpmEstimate, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoLoopBpmConfidence = factory.create("LoopBpmConfidence", "sampleRate", sampleRate); - algoLoopBpmConfidence->input("signal").set(input_signal); - algoLoopBpmConfidence->input("bpmEstimate").set(input_bpmEstimate); - float output_confidence; - algoLoopBpmConfidence->output("confidence").set(output_confidence); - algoLoopBpmConfidence->compute(); - val outputLoopBpmConfidence(val::object()); - outputLoopBpmConfidence.set("confidence", output_confidence); - delete algoLoopBpmConfidence; - return outputLoopBpmConfidence; -} - +LoopBpmConfidence::LoopBpmConfidence(const float sampleRate) { + configure(sampleRate); +} +LoopBpmConfidence::~LoopBpmConfidence() { + delete _loopbpmconfidence; +} +void LoopBpmConfidence::configure(const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _loopbpmconfidence = factory.create("LoopBpmConfidence", "sampleRate", sampleRate); +} +val LoopBpmConfidence::compute(std::vector& input_signal, float input_bpmEstimate) { + _loopbpmconfidence->input("signal").set(input_signal); + _loopbpmconfidence->input("bpmEstimate").set(input_bpmEstimate); + float output_confidence; + _loopbpmconfidence->output("confidence").set(output_confidence); + _loopbpmconfidence->compute(); + val outputLoopBpmConfidence(val::object()); + outputLoopBpmConfidence.set("confidence", output_confidence); + return outputLoopBpmConfidence; +} +void LoopBpmConfidence::reset() { +_loopbpmconfidence->reset(); +} +// END LoopBpmConfidence definitions + +// START LoopBpmEstimator definitions // check https://essentia.upf.edu/reference/std_LoopBpmEstimator.html -val EssentiaJS::LoopBpmEstimator(std::vector& input_signal, const float confidenceThreshold) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoLoopBpmEstimator = factory.create("LoopBpmEstimator", "confidenceThreshold", confidenceThreshold); - algoLoopBpmEstimator->input("signal").set(input_signal); - float output_bpm; - algoLoopBpmEstimator->output("bpm").set(output_bpm); - algoLoopBpmEstimator->compute(); - val outputLoopBpmEstimator(val::object()); - outputLoopBpmEstimator.set("bpm", output_bpm); - delete algoLoopBpmEstimator; - return outputLoopBpmEstimator; -} - +LoopBpmEstimator::LoopBpmEstimator(const float confidenceThreshold) { + configure(confidenceThreshold); +} +LoopBpmEstimator::~LoopBpmEstimator() { + delete _loopbpmestimator; +} +void LoopBpmEstimator::configure(const float confidenceThreshold) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _loopbpmestimator = factory.create("LoopBpmEstimator", "confidenceThreshold", confidenceThreshold); +} +val LoopBpmEstimator::compute(std::vector& input_signal) { + _loopbpmestimator->input("signal").set(input_signal); + float output_bpm; + _loopbpmestimator->output("bpm").set(output_bpm); + _loopbpmestimator->compute(); + val outputLoopBpmEstimator(val::object()); + outputLoopBpmEstimator.set("bpm", output_bpm); + return outputLoopBpmEstimator; +} +void LoopBpmEstimator::reset() { +_loopbpmestimator->reset(); +} +// END LoopBpmEstimator definitions + +// START Loudness definitions // check https://essentia.upf.edu/reference/std_Loudness.html -val EssentiaJS::Loudness(std::vector& input_signal) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoLoudness = factory.create("Loudness"); - algoLoudness->input("signal").set(input_signal); - float output_loudness; - algoLoudness->output("loudness").set(output_loudness); - algoLoudness->compute(); - val outputLoudness(val::object()); - outputLoudness.set("loudness", output_loudness); - delete algoLoudness; - return outputLoudness; -} - +Loudness::Loudness() { + configure(); +} +Loudness::~Loudness() { + delete _loudness; +} +void Loudness::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _loudness = factory.create("Loudness"); +} +val Loudness::compute(std::vector& input_signal) { + _loudness->input("signal").set(input_signal); + float output_loudness; + _loudness->output("loudness").set(output_loudness); + _loudness->compute(); + val outputLoudness(val::object()); + outputLoudness.set("loudness", output_loudness); + return outputLoudness; +} +void Loudness::reset() { +_loudness->reset(); +} +// END Loudness definitions + +// START LoudnessVickers definitions // check https://essentia.upf.edu/reference/std_LoudnessVickers.html -val EssentiaJS::LoudnessVickers(std::vector& input_signal, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoLoudnessVickers = factory.create("LoudnessVickers", "sampleRate", sampleRate); - algoLoudnessVickers->input("signal").set(input_signal); - float output_loudness; - algoLoudnessVickers->output("loudness").set(output_loudness); - algoLoudnessVickers->compute(); - val outputLoudnessVickers(val::object()); - outputLoudnessVickers.set("loudness", output_loudness); - delete algoLoudnessVickers; - return outputLoudnessVickers; -} - +LoudnessVickers::LoudnessVickers(const float sampleRate) { + configure(sampleRate); +} +LoudnessVickers::~LoudnessVickers() { + delete _loudnessvickers; +} +void LoudnessVickers::configure(const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _loudnessvickers = factory.create("LoudnessVickers", "sampleRate", sampleRate); +} +val LoudnessVickers::compute(std::vector& input_signal) { + _loudnessvickers->input("signal").set(input_signal); + float output_loudness; + _loudnessvickers->output("loudness").set(output_loudness); + _loudnessvickers->compute(); + val outputLoudnessVickers(val::object()); + outputLoudnessVickers.set("loudness", output_loudness); + return outputLoudnessVickers; +} +void LoudnessVickers::reset() { +_loudnessvickers->reset(); +} +// END LoudnessVickers definitions + +// START LowLevelSpectralEqloudExtractor definitions // check https://essentia.upf.edu/reference/std_LowLevelSpectralEqloudExtractor.html -val EssentiaJS::LowLevelSpectralEqloudExtractor(std::vector& input_signal, const int frameSize, const int hopSize, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoLowLevelSpectralEqloudExtractor = factory.create("LowLevelSpectralEqloudExtractor", "frameSize", frameSize, "hopSize", hopSize, "sampleRate", sampleRate); - algoLowLevelSpectralEqloudExtractor->input("signal").set(input_signal); - std::vector output_dissonance; - std::vector > output_sccoeffs; - std::vector > output_scvalleys; - std::vector output_spectral_centroid; - std::vector output_spectral_kurtosis; - std::vector output_spectral_skewness; - std::vector output_spectral_spread; - algoLowLevelSpectralEqloudExtractor->output("dissonance").set(output_dissonance); - algoLowLevelSpectralEqloudExtractor->output("sccoeffs").set(output_sccoeffs); - algoLowLevelSpectralEqloudExtractor->output("scvalleys").set(output_scvalleys); - algoLowLevelSpectralEqloudExtractor->output("spectral_centroid").set(output_spectral_centroid); - algoLowLevelSpectralEqloudExtractor->output("spectral_kurtosis").set(output_spectral_kurtosis); - algoLowLevelSpectralEqloudExtractor->output("spectral_skewness").set(output_spectral_skewness); - algoLowLevelSpectralEqloudExtractor->output("spectral_spread").set(output_spectral_spread); - algoLowLevelSpectralEqloudExtractor->compute(); - val outputLowLevelSpectralEqloudExtractor(val::object()); - outputLowLevelSpectralEqloudExtractor.set("dissonance", output_dissonance); - outputLowLevelSpectralEqloudExtractor.set("sccoeffs", output_sccoeffs); - outputLowLevelSpectralEqloudExtractor.set("scvalleys", output_scvalleys); - outputLowLevelSpectralEqloudExtractor.set("spectral_centroid", output_spectral_centroid); - outputLowLevelSpectralEqloudExtractor.set("spectral_kurtosis", output_spectral_kurtosis); - outputLowLevelSpectralEqloudExtractor.set("spectral_skewness", output_spectral_skewness); - outputLowLevelSpectralEqloudExtractor.set("spectral_spread", output_spectral_spread); - delete algoLowLevelSpectralEqloudExtractor; - return outputLowLevelSpectralEqloudExtractor; -} - +LowLevelSpectralEqloudExtractor::LowLevelSpectralEqloudExtractor(const int frameSize, const int hopSize, const float sampleRate) { + configure(frameSize, hopSize, sampleRate); +} +LowLevelSpectralEqloudExtractor::~LowLevelSpectralEqloudExtractor() { + delete _lowlevelspectraleqloudextractor; +} +void LowLevelSpectralEqloudExtractor::configure(const int frameSize, const int hopSize, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _lowlevelspectraleqloudextractor = factory.create("LowLevelSpectralEqloudExtractor", "frameSize", frameSize, "hopSize", hopSize, "sampleRate", sampleRate); +} +val LowLevelSpectralEqloudExtractor::compute(std::vector& input_signal) { + _lowlevelspectraleqloudextractor->input("signal").set(input_signal); + std::vector output_dissonance; + std::vector > output_sccoeffs; + std::vector > output_scvalleys; + std::vector output_spectral_centroid; + std::vector output_spectral_kurtosis; + std::vector output_spectral_skewness; + std::vector output_spectral_spread; + _lowlevelspectraleqloudextractor->output("dissonance").set(output_dissonance); + _lowlevelspectraleqloudextractor->output("sccoeffs").set(output_sccoeffs); + _lowlevelspectraleqloudextractor->output("scvalleys").set(output_scvalleys); + _lowlevelspectraleqloudextractor->output("spectral_centroid").set(output_spectral_centroid); + _lowlevelspectraleqloudextractor->output("spectral_kurtosis").set(output_spectral_kurtosis); + _lowlevelspectraleqloudextractor->output("spectral_skewness").set(output_spectral_skewness); + _lowlevelspectraleqloudextractor->output("spectral_spread").set(output_spectral_spread); + _lowlevelspectraleqloudextractor->compute(); + val outputLowLevelSpectralEqloudExtractor(val::object()); + outputLowLevelSpectralEqloudExtractor.set("dissonance", output_dissonance); + outputLowLevelSpectralEqloudExtractor.set("sccoeffs", output_sccoeffs); + outputLowLevelSpectralEqloudExtractor.set("scvalleys", output_scvalleys); + outputLowLevelSpectralEqloudExtractor.set("spectral_centroid", output_spectral_centroid); + outputLowLevelSpectralEqloudExtractor.set("spectral_kurtosis", output_spectral_kurtosis); + outputLowLevelSpectralEqloudExtractor.set("spectral_skewness", output_spectral_skewness); + outputLowLevelSpectralEqloudExtractor.set("spectral_spread", output_spectral_spread); + return outputLowLevelSpectralEqloudExtractor; +} +void LowLevelSpectralEqloudExtractor::reset() { +_lowlevelspectraleqloudextractor->reset(); +} +// END LowLevelSpectralEqloudExtractor definitions + +// START LowLevelSpectralExtractor definitions // check https://essentia.upf.edu/reference/std_LowLevelSpectralExtractor.html -val EssentiaJS::LowLevelSpectralExtractor(std::vector& input_signal, const int frameSize, const int hopSize, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoLowLevelSpectralExtractor = factory.create("LowLevelSpectralExtractor", "frameSize", frameSize, "hopSize", hopSize, "sampleRate", sampleRate); - algoLowLevelSpectralExtractor->input("signal").set(input_signal); - std::vector > output_barkbands; - std::vector output_barkbands_kurtosis; - std::vector output_barkbands_skewness; - std::vector output_barkbands_spread; - std::vector output_hfc; - std::vector > output_mfcc; - std::vector output_pitch; - std::vector output_pitch_instantaneous_confidence; - std::vector output_pitch_salience; - std::vector output_silence_rate_20dB; - std::vector output_silence_rate_30dB; - std::vector output_silence_rate_60dB; - std::vector output_spectral_complexity; - std::vector output_spectral_crest; - std::vector output_spectral_decrease; - std::vector output_spectral_energy; - std::vector output_spectral_energyband_low; - std::vector output_spectral_energyband_middle_low; - std::vector output_spectral_energyband_middle_high; - std::vector output_spectral_energyband_high; - std::vector output_spectral_flatness_db; - std::vector output_spectral_flux; - std::vector output_spectral_rms; - std::vector output_spectral_rolloff; - std::vector output_spectral_strongpeak; - std::vector output_zerocrossingrate; - std::vector output_inharmonicity; - std::vector > output_tristimulus; - std::vector output_oddtoevenharmonicenergyratio; - algoLowLevelSpectralExtractor->output("barkbands").set(output_barkbands); - algoLowLevelSpectralExtractor->output("barkbands_kurtosis").set(output_barkbands_kurtosis); - algoLowLevelSpectralExtractor->output("barkbands_skewness").set(output_barkbands_skewness); - algoLowLevelSpectralExtractor->output("barkbands_spread").set(output_barkbands_spread); - algoLowLevelSpectralExtractor->output("hfc").set(output_hfc); - algoLowLevelSpectralExtractor->output("mfcc").set(output_mfcc); - algoLowLevelSpectralExtractor->output("pitch").set(output_pitch); - algoLowLevelSpectralExtractor->output("pitch_instantaneous_confidence").set(output_pitch_instantaneous_confidence); - algoLowLevelSpectralExtractor->output("pitch_salience").set(output_pitch_salience); - algoLowLevelSpectralExtractor->output("silence_rate_20dB").set(output_silence_rate_20dB); - algoLowLevelSpectralExtractor->output("silence_rate_30dB").set(output_silence_rate_30dB); - algoLowLevelSpectralExtractor->output("silence_rate_60dB").set(output_silence_rate_60dB); - algoLowLevelSpectralExtractor->output("spectral_complexity").set(output_spectral_complexity); - algoLowLevelSpectralExtractor->output("spectral_crest").set(output_spectral_crest); - algoLowLevelSpectralExtractor->output("spectral_decrease").set(output_spectral_decrease); - algoLowLevelSpectralExtractor->output("spectral_energy").set(output_spectral_energy); - algoLowLevelSpectralExtractor->output("spectral_energyband_low").set(output_spectral_energyband_low); - algoLowLevelSpectralExtractor->output("spectral_energyband_middle_low").set(output_spectral_energyband_middle_low); - algoLowLevelSpectralExtractor->output("spectral_energyband_middle_high").set(output_spectral_energyband_middle_high); - algoLowLevelSpectralExtractor->output("spectral_energyband_high").set(output_spectral_energyband_high); - algoLowLevelSpectralExtractor->output("spectral_flatness_db").set(output_spectral_flatness_db); - algoLowLevelSpectralExtractor->output("spectral_flux").set(output_spectral_flux); - algoLowLevelSpectralExtractor->output("spectral_rms").set(output_spectral_rms); - algoLowLevelSpectralExtractor->output("spectral_rolloff").set(output_spectral_rolloff); - algoLowLevelSpectralExtractor->output("spectral_strongpeak").set(output_spectral_strongpeak); - algoLowLevelSpectralExtractor->output("zerocrossingrate").set(output_zerocrossingrate); - algoLowLevelSpectralExtractor->output("inharmonicity").set(output_inharmonicity); - algoLowLevelSpectralExtractor->output("tristimulus").set(output_tristimulus); - algoLowLevelSpectralExtractor->output("oddtoevenharmonicenergyratio").set(output_oddtoevenharmonicenergyratio); - algoLowLevelSpectralExtractor->compute(); - val outputLowLevelSpectralExtractor(val::object()); - outputLowLevelSpectralExtractor.set("barkbands", output_barkbands); - outputLowLevelSpectralExtractor.set("barkbands_kurtosis", output_barkbands_kurtosis); - outputLowLevelSpectralExtractor.set("barkbands_skewness", output_barkbands_skewness); - outputLowLevelSpectralExtractor.set("barkbands_spread", output_barkbands_spread); - outputLowLevelSpectralExtractor.set("hfc", output_hfc); - outputLowLevelSpectralExtractor.set("mfcc", output_mfcc); - outputLowLevelSpectralExtractor.set("pitch", output_pitch); - outputLowLevelSpectralExtractor.set("pitch_instantaneous_confidence", output_pitch_instantaneous_confidence); - outputLowLevelSpectralExtractor.set("pitch_salience", output_pitch_salience); - outputLowLevelSpectralExtractor.set("silence_rate_20dB", output_silence_rate_20dB); - outputLowLevelSpectralExtractor.set("silence_rate_30dB", output_silence_rate_30dB); - outputLowLevelSpectralExtractor.set("silence_rate_60dB", output_silence_rate_60dB); - outputLowLevelSpectralExtractor.set("spectral_complexity", output_spectral_complexity); - outputLowLevelSpectralExtractor.set("spectral_crest", output_spectral_crest); - outputLowLevelSpectralExtractor.set("spectral_decrease", output_spectral_decrease); - outputLowLevelSpectralExtractor.set("spectral_energy", output_spectral_energy); - outputLowLevelSpectralExtractor.set("spectral_energyband_low", output_spectral_energyband_low); - outputLowLevelSpectralExtractor.set("spectral_energyband_middle_low", output_spectral_energyband_middle_low); - outputLowLevelSpectralExtractor.set("spectral_energyband_middle_high", output_spectral_energyband_middle_high); - outputLowLevelSpectralExtractor.set("spectral_energyband_high", output_spectral_energyband_high); - outputLowLevelSpectralExtractor.set("spectral_flatness_db", output_spectral_flatness_db); - outputLowLevelSpectralExtractor.set("spectral_flux", output_spectral_flux); - outputLowLevelSpectralExtractor.set("spectral_rms", output_spectral_rms); - outputLowLevelSpectralExtractor.set("spectral_rolloff", output_spectral_rolloff); - outputLowLevelSpectralExtractor.set("spectral_strongpeak", output_spectral_strongpeak); - outputLowLevelSpectralExtractor.set("zerocrossingrate", output_zerocrossingrate); - outputLowLevelSpectralExtractor.set("inharmonicity", output_inharmonicity); - outputLowLevelSpectralExtractor.set("tristimulus", output_tristimulus); - outputLowLevelSpectralExtractor.set("oddtoevenharmonicenergyratio", output_oddtoevenharmonicenergyratio); - delete algoLowLevelSpectralExtractor; - return outputLowLevelSpectralExtractor; -} - +LowLevelSpectralExtractor::LowLevelSpectralExtractor(const int frameSize, const int hopSize, const float sampleRate) { + configure(frameSize, hopSize, sampleRate); +} +LowLevelSpectralExtractor::~LowLevelSpectralExtractor() { + delete _lowlevelspectralextractor; +} +void LowLevelSpectralExtractor::configure(const int frameSize, const int hopSize, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _lowlevelspectralextractor = factory.create("LowLevelSpectralExtractor", "frameSize", frameSize, "hopSize", hopSize, "sampleRate", sampleRate); +} +val LowLevelSpectralExtractor::compute(std::vector& input_signal) { + _lowlevelspectralextractor->input("signal").set(input_signal); + std::vector > output_barkbands; + std::vector output_barkbands_kurtosis; + std::vector output_barkbands_skewness; + std::vector output_barkbands_spread; + std::vector output_hfc; + std::vector > output_mfcc; + std::vector output_pitch; + std::vector output_pitch_instantaneous_confidence; + std::vector output_pitch_salience; + std::vector output_silence_rate_20dB; + std::vector output_silence_rate_30dB; + std::vector output_silence_rate_60dB; + std::vector output_spectral_complexity; + std::vector output_spectral_crest; + std::vector output_spectral_decrease; + std::vector output_spectral_energy; + std::vector output_spectral_energyband_low; + std::vector output_spectral_energyband_middle_low; + std::vector output_spectral_energyband_middle_high; + std::vector output_spectral_energyband_high; + std::vector output_spectral_flatness_db; + std::vector output_spectral_flux; + std::vector output_spectral_rms; + std::vector output_spectral_rolloff; + std::vector output_spectral_strongpeak; + std::vector output_zerocrossingrate; + std::vector output_inharmonicity; + std::vector > output_tristimulus; + std::vector output_oddtoevenharmonicenergyratio; + _lowlevelspectralextractor->output("barkbands").set(output_barkbands); + _lowlevelspectralextractor->output("barkbands_kurtosis").set(output_barkbands_kurtosis); + _lowlevelspectralextractor->output("barkbands_skewness").set(output_barkbands_skewness); + _lowlevelspectralextractor->output("barkbands_spread").set(output_barkbands_spread); + _lowlevelspectralextractor->output("hfc").set(output_hfc); + _lowlevelspectralextractor->output("mfcc").set(output_mfcc); + _lowlevelspectralextractor->output("pitch").set(output_pitch); + _lowlevelspectralextractor->output("pitch_instantaneous_confidence").set(output_pitch_instantaneous_confidence); + _lowlevelspectralextractor->output("pitch_salience").set(output_pitch_salience); + _lowlevelspectralextractor->output("silence_rate_20dB").set(output_silence_rate_20dB); + _lowlevelspectralextractor->output("silence_rate_30dB").set(output_silence_rate_30dB); + _lowlevelspectralextractor->output("silence_rate_60dB").set(output_silence_rate_60dB); + _lowlevelspectralextractor->output("spectral_complexity").set(output_spectral_complexity); + _lowlevelspectralextractor->output("spectral_crest").set(output_spectral_crest); + _lowlevelspectralextractor->output("spectral_decrease").set(output_spectral_decrease); + _lowlevelspectralextractor->output("spectral_energy").set(output_spectral_energy); + _lowlevelspectralextractor->output("spectral_energyband_low").set(output_spectral_energyband_low); + _lowlevelspectralextractor->output("spectral_energyband_middle_low").set(output_spectral_energyband_middle_low); + _lowlevelspectralextractor->output("spectral_energyband_middle_high").set(output_spectral_energyband_middle_high); + _lowlevelspectralextractor->output("spectral_energyband_high").set(output_spectral_energyband_high); + _lowlevelspectralextractor->output("spectral_flatness_db").set(output_spectral_flatness_db); + _lowlevelspectralextractor->output("spectral_flux").set(output_spectral_flux); + _lowlevelspectralextractor->output("spectral_rms").set(output_spectral_rms); + _lowlevelspectralextractor->output("spectral_rolloff").set(output_spectral_rolloff); + _lowlevelspectralextractor->output("spectral_strongpeak").set(output_spectral_strongpeak); + _lowlevelspectralextractor->output("zerocrossingrate").set(output_zerocrossingrate); + _lowlevelspectralextractor->output("inharmonicity").set(output_inharmonicity); + _lowlevelspectralextractor->output("tristimulus").set(output_tristimulus); + _lowlevelspectralextractor->output("oddtoevenharmonicenergyratio").set(output_oddtoevenharmonicenergyratio); + _lowlevelspectralextractor->compute(); + val outputLowLevelSpectralExtractor(val::object()); + outputLowLevelSpectralExtractor.set("barkbands", output_barkbands); + outputLowLevelSpectralExtractor.set("barkbands_kurtosis", output_barkbands_kurtosis); + outputLowLevelSpectralExtractor.set("barkbands_skewness", output_barkbands_skewness); + outputLowLevelSpectralExtractor.set("barkbands_spread", output_barkbands_spread); + outputLowLevelSpectralExtractor.set("hfc", output_hfc); + outputLowLevelSpectralExtractor.set("mfcc", output_mfcc); + outputLowLevelSpectralExtractor.set("pitch", output_pitch); + outputLowLevelSpectralExtractor.set("pitch_instantaneous_confidence", output_pitch_instantaneous_confidence); + outputLowLevelSpectralExtractor.set("pitch_salience", output_pitch_salience); + outputLowLevelSpectralExtractor.set("silence_rate_20dB", output_silence_rate_20dB); + outputLowLevelSpectralExtractor.set("silence_rate_30dB", output_silence_rate_30dB); + outputLowLevelSpectralExtractor.set("silence_rate_60dB", output_silence_rate_60dB); + outputLowLevelSpectralExtractor.set("spectral_complexity", output_spectral_complexity); + outputLowLevelSpectralExtractor.set("spectral_crest", output_spectral_crest); + outputLowLevelSpectralExtractor.set("spectral_decrease", output_spectral_decrease); + outputLowLevelSpectralExtractor.set("spectral_energy", output_spectral_energy); + outputLowLevelSpectralExtractor.set("spectral_energyband_low", output_spectral_energyband_low); + outputLowLevelSpectralExtractor.set("spectral_energyband_middle_low", output_spectral_energyband_middle_low); + outputLowLevelSpectralExtractor.set("spectral_energyband_middle_high", output_spectral_energyband_middle_high); + outputLowLevelSpectralExtractor.set("spectral_energyband_high", output_spectral_energyband_high); + outputLowLevelSpectralExtractor.set("spectral_flatness_db", output_spectral_flatness_db); + outputLowLevelSpectralExtractor.set("spectral_flux", output_spectral_flux); + outputLowLevelSpectralExtractor.set("spectral_rms", output_spectral_rms); + outputLowLevelSpectralExtractor.set("spectral_rolloff", output_spectral_rolloff); + outputLowLevelSpectralExtractor.set("spectral_strongpeak", output_spectral_strongpeak); + outputLowLevelSpectralExtractor.set("zerocrossingrate", output_zerocrossingrate); + outputLowLevelSpectralExtractor.set("inharmonicity", output_inharmonicity); + outputLowLevelSpectralExtractor.set("tristimulus", output_tristimulus); + outputLowLevelSpectralExtractor.set("oddtoevenharmonicenergyratio", output_oddtoevenharmonicenergyratio); + return outputLowLevelSpectralExtractor; +} +void LowLevelSpectralExtractor::reset() { +_lowlevelspectralextractor->reset(); +} +// END LowLevelSpectralExtractor definitions + +// START LowPass definitions // check https://essentia.upf.edu/reference/std_LowPass.html -val EssentiaJS::LowPass(std::vector& input_signal, const float cutoffFrequency, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoLowPass = factory.create("LowPass", "cutoffFrequency", cutoffFrequency, "sampleRate", sampleRate); - algoLowPass->input("signal").set(input_signal); - std::vector output_signal; - algoLowPass->output("signal").set(output_signal); - algoLowPass->compute(); - val outputLowPass(val::object()); - outputLowPass.set("signal", output_signal); - delete algoLowPass; - return outputLowPass; -} - +LowPass::LowPass(const float cutoffFrequency, const float sampleRate) { + configure(cutoffFrequency, sampleRate); +} +LowPass::~LowPass() { + delete _lowpass; +} +void LowPass::configure(const float cutoffFrequency, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _lowpass = factory.create("LowPass", "cutoffFrequency", cutoffFrequency, "sampleRate", sampleRate); +} +val LowPass::compute(std::vector& input_signal) { + _lowpass->input("signal").set(input_signal); + std::vector output_signal; + _lowpass->output("signal").set(output_signal); + _lowpass->compute(); + val outputLowPass(val::object()); + outputLowPass.set("signal", output_signal); + return outputLowPass; +} +void LowPass::reset() { +_lowpass->reset(); +} +// END LowPass definitions + +// START MFCC definitions // check https://essentia.upf.edu/reference/std_MFCC.html -val EssentiaJS::MFCC(std::vector& input_spectrum, const int dctType, const float highFrequencyBound, const int inputSize, const int liftering, const std::string& logType, const float lowFrequencyBound, const std::string& normalize, const int numberBands, const int numberCoefficients, const float sampleRate, const float silenceThreshold, const std::string& type, const std::string& warpingFormula, const std::string& weighting) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoMFCC = factory.create("MFCC", "dctType", dctType, "highFrequencyBound", highFrequencyBound, "inputSize", inputSize, "liftering", liftering, "logType", logType, "lowFrequencyBound", lowFrequencyBound, "normalize", normalize, "numberBands", numberBands, "numberCoefficients", numberCoefficients, "sampleRate", sampleRate, "silenceThreshold", silenceThreshold, "type", type, "warpingFormula", warpingFormula, "weighting", weighting); - algoMFCC->input("spectrum").set(input_spectrum); - std::vector output_bands; - std::vector output_mfcc; - algoMFCC->output("bands").set(output_bands); - algoMFCC->output("mfcc").set(output_mfcc); - algoMFCC->compute(); - val outputMFCC(val::object()); - outputMFCC.set("bands", output_bands); - outputMFCC.set("mfcc", output_mfcc); - delete algoMFCC; - return outputMFCC; -} - +MFCC::MFCC(const int dctType, const float highFrequencyBound, const int inputSize, const int liftering, const std::string& logType, const float lowFrequencyBound, const std::string& normalize, const int numberBands, const int numberCoefficients, const float sampleRate, const float silenceThreshold, const std::string& type, const std::string& warpingFormula, const std::string& weighting) { + configure(dctType, highFrequencyBound, inputSize, liftering, logType, lowFrequencyBound, normalize, numberBands, numberCoefficients, sampleRate, silenceThreshold, type, warpingFormula, weighting); +} +MFCC::~MFCC() { + delete _mfcc; +} +void MFCC::configure(const int dctType, const float highFrequencyBound, const int inputSize, const int liftering, const std::string& logType, const float lowFrequencyBound, const std::string& normalize, const int numberBands, const int numberCoefficients, const float sampleRate, const float silenceThreshold, const std::string& type, const std::string& warpingFormula, const std::string& weighting) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _mfcc = factory.create("MFCC", "dctType", dctType, "highFrequencyBound", highFrequencyBound, "inputSize", inputSize, "liftering", liftering, "logType", logType, "lowFrequencyBound", lowFrequencyBound, "normalize", normalize, "numberBands", numberBands, "numberCoefficients", numberCoefficients, "sampleRate", sampleRate, "silenceThreshold", silenceThreshold, "type", type, "warpingFormula", warpingFormula, "weighting", weighting); +} +val MFCC::compute(std::vector& input_spectrum) { + _mfcc->input("spectrum").set(input_spectrum); + std::vector output_bands; + std::vector output_mfcc; + _mfcc->output("bands").set(output_bands); + _mfcc->output("mfcc").set(output_mfcc); + _mfcc->compute(); + val outputMFCC(val::object()); + outputMFCC.set("bands", output_bands); + outputMFCC.set("mfcc", output_mfcc); + return outputMFCC; +} +void MFCC::reset() { +_mfcc->reset(); +} +// END MFCC definitions + +// START MaxFilter definitions // check https://essentia.upf.edu/reference/std_MaxFilter.html -val EssentiaJS::MaxFilter(std::vector& input_signal, const bool causal, const int width) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoMaxFilter = factory.create("MaxFilter", "causal", causal, "width", width); - algoMaxFilter->input("signal").set(input_signal); - std::vector output_signal; - algoMaxFilter->output("signal").set(output_signal); - algoMaxFilter->compute(); - val outputMaxFilter(val::object()); - outputMaxFilter.set("signal", output_signal); - delete algoMaxFilter; - return outputMaxFilter; -} - +MaxFilter::MaxFilter(const bool causal, const int width) { + configure(causal, width); +} +MaxFilter::~MaxFilter() { + delete _maxfilter; +} +void MaxFilter::configure(const bool causal, const int width) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _maxfilter = factory.create("MaxFilter", "causal", causal, "width", width); +} +val MaxFilter::compute(std::vector& input_signal) { + _maxfilter->input("signal").set(input_signal); + std::vector output_signal; + _maxfilter->output("signal").set(output_signal); + _maxfilter->compute(); + val outputMaxFilter(val::object()); + outputMaxFilter.set("signal", output_signal); + return outputMaxFilter; +} +void MaxFilter::reset() { +_maxfilter->reset(); +} +// END MaxFilter definitions + +// START MaxMagFreq definitions // check https://essentia.upf.edu/reference/std_MaxMagFreq.html -val EssentiaJS::MaxMagFreq(std::vector& input_spectrum, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoMaxMagFreq = factory.create("MaxMagFreq", "sampleRate", sampleRate); - algoMaxMagFreq->input("spectrum").set(input_spectrum); - float output_maxMagFreq; - algoMaxMagFreq->output("maxMagFreq").set(output_maxMagFreq); - algoMaxMagFreq->compute(); - val outputMaxMagFreq(val::object()); - outputMaxMagFreq.set("maxMagFreq", output_maxMagFreq); - delete algoMaxMagFreq; - return outputMaxMagFreq; -} - +MaxMagFreq::MaxMagFreq(const float sampleRate) { + configure(sampleRate); +} +MaxMagFreq::~MaxMagFreq() { + delete _maxmagfreq; +} +void MaxMagFreq::configure(const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _maxmagfreq = factory.create("MaxMagFreq", "sampleRate", sampleRate); +} +val MaxMagFreq::compute(std::vector& input_spectrum) { + _maxmagfreq->input("spectrum").set(input_spectrum); + float output_maxMagFreq; + _maxmagfreq->output("maxMagFreq").set(output_maxMagFreq); + _maxmagfreq->compute(); + val outputMaxMagFreq(val::object()); + outputMaxMagFreq.set("maxMagFreq", output_maxMagFreq); + return outputMaxMagFreq; +} +void MaxMagFreq::reset() { +_maxmagfreq->reset(); +} +// END MaxMagFreq definitions + +// START MaxToTotal definitions // check https://essentia.upf.edu/reference/std_MaxToTotal.html -val EssentiaJS::MaxToTotal(std::vector& input_envelope) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoMaxToTotal = factory.create("MaxToTotal"); - algoMaxToTotal->input("envelope").set(input_envelope); - float output_maxToTotal; - algoMaxToTotal->output("maxToTotal").set(output_maxToTotal); - algoMaxToTotal->compute(); - val outputMaxToTotal(val::object()); - outputMaxToTotal.set("maxToTotal", output_maxToTotal); - delete algoMaxToTotal; - return outputMaxToTotal; -} - +MaxToTotal::MaxToTotal() { + configure(); +} +MaxToTotal::~MaxToTotal() { + delete _maxtototal; +} +void MaxToTotal::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _maxtototal = factory.create("MaxToTotal"); +} +val MaxToTotal::compute(std::vector& input_envelope) { + _maxtototal->input("envelope").set(input_envelope); + float output_maxToTotal; + _maxtototal->output("maxToTotal").set(output_maxToTotal); + _maxtototal->compute(); + val outputMaxToTotal(val::object()); + outputMaxToTotal.set("maxToTotal", output_maxToTotal); + return outputMaxToTotal; +} +void MaxToTotal::reset() { +_maxtototal->reset(); +} +// END MaxToTotal definitions + +// START Mean definitions // check https://essentia.upf.edu/reference/std_Mean.html -val EssentiaJS::Mean(std::vector& input_array) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoMean = factory.create("Mean"); - algoMean->input("array").set(input_array); - float output_mean; - algoMean->output("mean").set(output_mean); - algoMean->compute(); - val outputMean(val::object()); - outputMean.set("mean", output_mean); - delete algoMean; - return outputMean; -} - +Mean::Mean() { + configure(); +} +Mean::~Mean() { + delete _mean; +} +void Mean::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _mean = factory.create("Mean"); +} +val Mean::compute(std::vector& input_array) { + _mean->input("array").set(input_array); + float output_mean; + _mean->output("mean").set(output_mean); + _mean->compute(); + val outputMean(val::object()); + outputMean.set("mean", output_mean); + return outputMean; +} +void Mean::reset() { +_mean->reset(); +} +// END Mean definitions + +// START Median definitions // check https://essentia.upf.edu/reference/std_Median.html -val EssentiaJS::Median(std::vector& input_array) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoMedian = factory.create("Median"); - algoMedian->input("array").set(input_array); - float output_median; - algoMedian->output("median").set(output_median); - algoMedian->compute(); - val outputMedian(val::object()); - outputMedian.set("median", output_median); - delete algoMedian; - return outputMedian; -} - +Median::Median() { + configure(); +} +Median::~Median() { + delete _median; +} +void Median::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _median = factory.create("Median"); +} +val Median::compute(std::vector& input_array) { + _median->input("array").set(input_array); + float output_median; + _median->output("median").set(output_median); + _median->compute(); + val outputMedian(val::object()); + outputMedian.set("median", output_median); + return outputMedian; +} +void Median::reset() { +_median->reset(); +} +// END Median definitions + +// START MedianFilter definitions // check https://essentia.upf.edu/reference/std_MedianFilter.html -val EssentiaJS::MedianFilter(std::vector& input_array, const int kernelSize) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoMedianFilter = factory.create("MedianFilter", "kernelSize", kernelSize); - algoMedianFilter->input("array").set(input_array); - std::vector output_filteredArray; - algoMedianFilter->output("filteredArray").set(output_filteredArray); - algoMedianFilter->compute(); - val outputMedianFilter(val::object()); - outputMedianFilter.set("filteredArray", output_filteredArray); - delete algoMedianFilter; - return outputMedianFilter; -} - +MedianFilter::MedianFilter(const int kernelSize) { + configure(kernelSize); +} +MedianFilter::~MedianFilter() { + delete _medianfilter; +} +void MedianFilter::configure(const int kernelSize) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _medianfilter = factory.create("MedianFilter", "kernelSize", kernelSize); +} +val MedianFilter::compute(std::vector& input_array) { + _medianfilter->input("array").set(input_array); + std::vector output_filteredArray; + _medianfilter->output("filteredArray").set(output_filteredArray); + _medianfilter->compute(); + val outputMedianFilter(val::object()); + outputMedianFilter.set("filteredArray", output_filteredArray); + return outputMedianFilter; +} +void MedianFilter::reset() { +_medianfilter->reset(); +} +// END MedianFilter definitions + +// START MelBands definitions // check https://essentia.upf.edu/reference/std_MelBands.html -val EssentiaJS::MelBands(std::vector& input_spectrum, const float highFrequencyBound, const int inputSize, const bool log, const float lowFrequencyBound, const std::string& normalize, const int numberBands, const float sampleRate, const std::string& type, const std::string& warpingFormula, const std::string& weighting) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoMelBands = factory.create("MelBands", "highFrequencyBound", highFrequencyBound, "inputSize", inputSize, "log", log, "lowFrequencyBound", lowFrequencyBound, "normalize", normalize, "numberBands", numberBands, "sampleRate", sampleRate, "type", type, "warpingFormula", warpingFormula, "weighting", weighting); - algoMelBands->input("spectrum").set(input_spectrum); - std::vector output_bands; - algoMelBands->output("bands").set(output_bands); - algoMelBands->compute(); - val outputMelBands(val::object()); - outputMelBands.set("bands", output_bands); - delete algoMelBands; - return outputMelBands; -} - +MelBands::MelBands(const float highFrequencyBound, const int inputSize, const bool log, const float lowFrequencyBound, const std::string& normalize, const int numberBands, const float sampleRate, const std::string& type, const std::string& warpingFormula, const std::string& weighting) { + configure(highFrequencyBound, inputSize, log, lowFrequencyBound, normalize, numberBands, sampleRate, type, warpingFormula, weighting); +} +MelBands::~MelBands() { + delete _melbands; +} +void MelBands::configure(const float highFrequencyBound, const int inputSize, const bool log, const float lowFrequencyBound, const std::string& normalize, const int numberBands, const float sampleRate, const std::string& type, const std::string& warpingFormula, const std::string& weighting) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _melbands = factory.create("MelBands", "highFrequencyBound", highFrequencyBound, "inputSize", inputSize, "log", log, "lowFrequencyBound", lowFrequencyBound, "normalize", normalize, "numberBands", numberBands, "sampleRate", sampleRate, "type", type, "warpingFormula", warpingFormula, "weighting", weighting); +} +val MelBands::compute(std::vector& input_spectrum) { + _melbands->input("spectrum").set(input_spectrum); + std::vector output_bands; + _melbands->output("bands").set(output_bands); + _melbands->compute(); + val outputMelBands(val::object()); + outputMelBands.set("bands", output_bands); + return outputMelBands; +} +void MelBands::reset() { +_melbands->reset(); +} +// END MelBands definitions + +// START Meter definitions // check https://essentia.upf.edu/reference/std_Meter.html -val EssentiaJS::Meter(std::vector >& input_beatogram) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoMeter = factory.create("Meter"); - algoMeter->input("beatogram").set(input_beatogram); - float output_meter; - algoMeter->output("meter").set(output_meter); - algoMeter->compute(); - val outputMeter(val::object()); - outputMeter.set("meter", output_meter); - delete algoMeter; - return outputMeter; -} - +Meter::Meter() { + configure(); +} +Meter::~Meter() { + delete _meter; +} +void Meter::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _meter = factory.create("Meter"); +} +val Meter::compute(std::vector >& input_beatogram) { + _meter->input("beatogram").set(input_beatogram); + float output_meter; + _meter->output("meter").set(output_meter); + _meter->compute(); + val outputMeter(val::object()); + outputMeter.set("meter", output_meter); + return outputMeter; +} +void Meter::reset() { +_meter->reset(); +} +// END Meter definitions + +// START MinMax definitions // check https://essentia.upf.edu/reference/std_MinMax.html -val EssentiaJS::MinMax(std::vector& input_array, const std::string& type) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoMinMax = factory.create("MinMax", "type", type); - algoMinMax->input("array").set(input_array); - float output_real; - int output_int; - algoMinMax->output("real").set(output_real); - algoMinMax->output("int").set(output_int); - algoMinMax->compute(); - val outputMinMax(val::object()); - outputMinMax.set("real", output_real); - outputMinMax.set("int", output_int); - delete algoMinMax; - return outputMinMax; -} - +MinMax::MinMax(const std::string& type) { + configure(type); +} +MinMax::~MinMax() { + delete _minmax; +} +void MinMax::configure(const std::string& type) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _minmax = factory.create("MinMax", "type", type); +} +val MinMax::compute(std::vector& input_array) { + _minmax->input("array").set(input_array); + float output_real; + int output_int; + _minmax->output("real").set(output_real); + _minmax->output("int").set(output_int); + _minmax->compute(); + val outputMinMax(val::object()); + outputMinMax.set("real", output_real); + outputMinMax.set("int", output_int); + return outputMinMax; +} +void MinMax::reset() { +_minmax->reset(); +} +// END MinMax definitions + +// START MinToTotal definitions // check https://essentia.upf.edu/reference/std_MinToTotal.html -val EssentiaJS::MinToTotal(std::vector& input_envelope) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoMinToTotal = factory.create("MinToTotal"); - algoMinToTotal->input("envelope").set(input_envelope); - float output_minToTotal; - algoMinToTotal->output("minToTotal").set(output_minToTotal); - algoMinToTotal->compute(); - val outputMinToTotal(val::object()); - outputMinToTotal.set("minToTotal", output_minToTotal); - delete algoMinToTotal; - return outputMinToTotal; -} - +MinToTotal::MinToTotal() { + configure(); +} +MinToTotal::~MinToTotal() { + delete _mintototal; +} +void MinToTotal::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _mintototal = factory.create("MinToTotal"); +} +val MinToTotal::compute(std::vector& input_envelope) { + _mintototal->input("envelope").set(input_envelope); + float output_minToTotal; + _mintototal->output("minToTotal").set(output_minToTotal); + _mintototal->compute(); + val outputMinToTotal(val::object()); + outputMinToTotal.set("minToTotal", output_minToTotal); + return outputMinToTotal; +} +void MinToTotal::reset() { +_mintototal->reset(); +} +// END MinToTotal definitions + +// START MovingAverage definitions // check https://essentia.upf.edu/reference/std_MovingAverage.html -val EssentiaJS::MovingAverage(std::vector& input_signal, const int size) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoMovingAverage = factory.create("MovingAverage", "size", size); - algoMovingAverage->input("signal").set(input_signal); - std::vector output_signal; - algoMovingAverage->output("signal").set(output_signal); - algoMovingAverage->compute(); - val outputMovingAverage(val::object()); - outputMovingAverage.set("signal", output_signal); - delete algoMovingAverage; - return outputMovingAverage; -} - +MovingAverage::MovingAverage(const int size) { + configure(size); +} +MovingAverage::~MovingAverage() { + delete _movingaverage; +} +void MovingAverage::configure(const int size) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _movingaverage = factory.create("MovingAverage", "size", size); +} +val MovingAverage::compute(std::vector& input_signal) { + _movingaverage->input("signal").set(input_signal); + std::vector output_signal; + _movingaverage->output("signal").set(output_signal); + _movingaverage->compute(); + val outputMovingAverage(val::object()); + outputMovingAverage.set("signal", output_signal); + return outputMovingAverage; +} +void MovingAverage::reset() { +_movingaverage->reset(); +} +// END MovingAverage definitions + +// START MultiPitchKlapuri definitions // check https://essentia.upf.edu/reference/std_MultiPitchKlapuri.html -val EssentiaJS::MultiPitchKlapuri(std::vector& input_signal, const float binResolution, const int frameSize, const float harmonicWeight, const int hopSize, const float magnitudeCompression, const int magnitudeThreshold, const float maxFrequency, const float minFrequency, const int numberHarmonics, const float referenceFrequency, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoMultiPitchKlapuri = factory.create("MultiPitchKlapuri", "binResolution", binResolution, "frameSize", frameSize, "harmonicWeight", harmonicWeight, "hopSize", hopSize, "magnitudeCompression", magnitudeCompression, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "minFrequency", minFrequency, "numberHarmonics", numberHarmonics, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate); - algoMultiPitchKlapuri->input("signal").set(input_signal); - std::vector > output_pitch; - algoMultiPitchKlapuri->output("pitch").set(output_pitch); - algoMultiPitchKlapuri->compute(); - val outputMultiPitchKlapuri(val::object()); - outputMultiPitchKlapuri.set("pitch", output_pitch); - delete algoMultiPitchKlapuri; - return outputMultiPitchKlapuri; -} - +MultiPitchKlapuri::MultiPitchKlapuri(const float binResolution, const int frameSize, const float harmonicWeight, const int hopSize, const float magnitudeCompression, const int magnitudeThreshold, const float maxFrequency, const float minFrequency, const int numberHarmonics, const float referenceFrequency, const float sampleRate) { + configure(binResolution, frameSize, harmonicWeight, hopSize, magnitudeCompression, magnitudeThreshold, maxFrequency, minFrequency, numberHarmonics, referenceFrequency, sampleRate); +} +MultiPitchKlapuri::~MultiPitchKlapuri() { + delete _multipitchklapuri; +} +void MultiPitchKlapuri::configure(const float binResolution, const int frameSize, const float harmonicWeight, const int hopSize, const float magnitudeCompression, const int magnitudeThreshold, const float maxFrequency, const float minFrequency, const int numberHarmonics, const float referenceFrequency, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _multipitchklapuri = factory.create("MultiPitchKlapuri", "binResolution", binResolution, "frameSize", frameSize, "harmonicWeight", harmonicWeight, "hopSize", hopSize, "magnitudeCompression", magnitudeCompression, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "minFrequency", minFrequency, "numberHarmonics", numberHarmonics, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate); +} +val MultiPitchKlapuri::compute(std::vector& input_signal) { + _multipitchklapuri->input("signal").set(input_signal); + std::vector > output_pitch; + _multipitchklapuri->output("pitch").set(output_pitch); + _multipitchklapuri->compute(); + val outputMultiPitchKlapuri(val::object()); + outputMultiPitchKlapuri.set("pitch", output_pitch); + return outputMultiPitchKlapuri; +} +void MultiPitchKlapuri::reset() { +_multipitchklapuri->reset(); +} +// END MultiPitchKlapuri definitions + +// START MultiPitchMelodia definitions // check https://essentia.upf.edu/reference/std_MultiPitchMelodia.html -val EssentiaJS::MultiPitchMelodia(std::vector& input_signal, const float binResolution, const int filterIterations, const int frameSize, const bool guessUnvoiced, const float harmonicWeight, const int hopSize, const float magnitudeCompression, const int magnitudeThreshold, const float maxFrequency, const int minDuration, const float minFrequency, const int numberHarmonics, const float peakDistributionThreshold, const float peakFrameThreshold, const float pitchContinuity, const float referenceFrequency, const float sampleRate, const int timeContinuity) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoMultiPitchMelodia = factory.create("MultiPitchMelodia", "binResolution", binResolution, "filterIterations", filterIterations, "frameSize", frameSize, "guessUnvoiced", guessUnvoiced, "harmonicWeight", harmonicWeight, "hopSize", hopSize, "magnitudeCompression", magnitudeCompression, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "minDuration", minDuration, "minFrequency", minFrequency, "numberHarmonics", numberHarmonics, "peakDistributionThreshold", peakDistributionThreshold, "peakFrameThreshold", peakFrameThreshold, "pitchContinuity", pitchContinuity, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate, "timeContinuity", timeContinuity); - algoMultiPitchMelodia->input("signal").set(input_signal); - std::vector > output_pitch; - algoMultiPitchMelodia->output("pitch").set(output_pitch); - algoMultiPitchMelodia->compute(); - val outputMultiPitchMelodia(val::object()); - outputMultiPitchMelodia.set("pitch", output_pitch); - delete algoMultiPitchMelodia; - return outputMultiPitchMelodia; -} - +MultiPitchMelodia::MultiPitchMelodia(const float binResolution, const int filterIterations, const int frameSize, const bool guessUnvoiced, const float harmonicWeight, const int hopSize, const float magnitudeCompression, const int magnitudeThreshold, const float maxFrequency, const int minDuration, const float minFrequency, const int numberHarmonics, const float peakDistributionThreshold, const float peakFrameThreshold, const float pitchContinuity, const float referenceFrequency, const float sampleRate, const int timeContinuity) { + configure(binResolution, filterIterations, frameSize, guessUnvoiced, harmonicWeight, hopSize, magnitudeCompression, magnitudeThreshold, maxFrequency, minDuration, minFrequency, numberHarmonics, peakDistributionThreshold, peakFrameThreshold, pitchContinuity, referenceFrequency, sampleRate, timeContinuity); +} +MultiPitchMelodia::~MultiPitchMelodia() { + delete _multipitchmelodia; +} +void MultiPitchMelodia::configure(const float binResolution, const int filterIterations, const int frameSize, const bool guessUnvoiced, const float harmonicWeight, const int hopSize, const float magnitudeCompression, const int magnitudeThreshold, const float maxFrequency, const int minDuration, const float minFrequency, const int numberHarmonics, const float peakDistributionThreshold, const float peakFrameThreshold, const float pitchContinuity, const float referenceFrequency, const float sampleRate, const int timeContinuity) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _multipitchmelodia = factory.create("MultiPitchMelodia", "binResolution", binResolution, "filterIterations", filterIterations, "frameSize", frameSize, "guessUnvoiced", guessUnvoiced, "harmonicWeight", harmonicWeight, "hopSize", hopSize, "magnitudeCompression", magnitudeCompression, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "minDuration", minDuration, "minFrequency", minFrequency, "numberHarmonics", numberHarmonics, "peakDistributionThreshold", peakDistributionThreshold, "peakFrameThreshold", peakFrameThreshold, "pitchContinuity", pitchContinuity, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate, "timeContinuity", timeContinuity); +} +val MultiPitchMelodia::compute(std::vector& input_signal) { + _multipitchmelodia->input("signal").set(input_signal); + std::vector > output_pitch; + _multipitchmelodia->output("pitch").set(output_pitch); + _multipitchmelodia->compute(); + val outputMultiPitchMelodia(val::object()); + outputMultiPitchMelodia.set("pitch", output_pitch); + return outputMultiPitchMelodia; +} +void MultiPitchMelodia::reset() { +_multipitchmelodia->reset(); +} +// END MultiPitchMelodia definitions + +// START Multiplexer definitions // check https://essentia.upf.edu/reference/std_Multiplexer.html -val EssentiaJS::Multiplexer(const int numberRealInputs, const int numberVectorRealInputs) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoMultiplexer = factory.create("Multiplexer", "numberRealInputs", numberRealInputs, "numberVectorRealInputs", numberVectorRealInputs); - std::vector > output_data; - algoMultiplexer->output("data").set(output_data); - algoMultiplexer->compute(); - val outputMultiplexer(val::object()); - outputMultiplexer.set("data", output_data); - delete algoMultiplexer; - return outputMultiplexer; -} - +Multiplexer::Multiplexer(const int numberRealInputs, const int numberVectorRealInputs) { + configure(numberRealInputs, numberVectorRealInputs); +} +Multiplexer::~Multiplexer() { + delete _multiplexer; +} +void Multiplexer::configure(const int numberRealInputs, const int numberVectorRealInputs) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _multiplexer = factory.create("Multiplexer", "numberRealInputs", numberRealInputs, "numberVectorRealInputs", numberVectorRealInputs); +} +val Multiplexer::compute() { + std::vector > output_data; + _multiplexer->output("data").set(output_data); + _multiplexer->compute(); + val outputMultiplexer(val::object()); + outputMultiplexer.set("data", output_data); + return outputMultiplexer; +} +void Multiplexer::reset() { +_multiplexer->reset(); +} +// END Multiplexer definitions + +// START NNLSChroma definitions // check https://essentia.upf.edu/reference/std_NNLSChroma.html -val EssentiaJS::NNLSChroma(std::vector >& input_logSpectrogram, std::vector& input_meanTuning, std::vector& input_localTuning, const std::string& chromaNormalization, const int frameSize, const float sampleRate, const float spectralShape, const float spectralWhitening, const std::string& tuningMode, const bool useNNLS) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoNNLSChroma = factory.create("NNLSChroma", "chromaNormalization", chromaNormalization, "frameSize", frameSize, "sampleRate", sampleRate, "spectralShape", spectralShape, "spectralWhitening", spectralWhitening, "tuningMode", tuningMode, "useNNLS", useNNLS); - algoNNLSChroma->input("logSpectrogram").set(input_logSpectrogram); - algoNNLSChroma->input("meanTuning").set(input_meanTuning); - algoNNLSChroma->input("localTuning").set(input_localTuning); - std::vector > output_tunedLogfreqSpectrum; - std::vector > output_semitoneSpectrum; - std::vector > output_bassChromagram; - std::vector > output_chromagram; - algoNNLSChroma->output("tunedLogfreqSpectrum").set(output_tunedLogfreqSpectrum); - algoNNLSChroma->output("semitoneSpectrum").set(output_semitoneSpectrum); - algoNNLSChroma->output("bassChromagram").set(output_bassChromagram); - algoNNLSChroma->output("chromagram").set(output_chromagram); - algoNNLSChroma->compute(); - val outputNNLSChroma(val::object()); - outputNNLSChroma.set("tunedLogfreqSpectrum", output_tunedLogfreqSpectrum); - outputNNLSChroma.set("semitoneSpectrum", output_semitoneSpectrum); - outputNNLSChroma.set("bassChromagram", output_bassChromagram); - outputNNLSChroma.set("chromagram", output_chromagram); - delete algoNNLSChroma; - return outputNNLSChroma; -} - +NNLSChroma::NNLSChroma(const std::string& chromaNormalization, const int frameSize, const float sampleRate, const float spectralShape, const float spectralWhitening, const std::string& tuningMode, const bool useNNLS) { + configure(chromaNormalization, frameSize, sampleRate, spectralShape, spectralWhitening, tuningMode, useNNLS); +} +NNLSChroma::~NNLSChroma() { + delete _nnlschroma; +} +void NNLSChroma::configure(const std::string& chromaNormalization, const int frameSize, const float sampleRate, const float spectralShape, const float spectralWhitening, const std::string& tuningMode, const bool useNNLS) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _nnlschroma = factory.create("NNLSChroma", "chromaNormalization", chromaNormalization, "frameSize", frameSize, "sampleRate", sampleRate, "spectralShape", spectralShape, "spectralWhitening", spectralWhitening, "tuningMode", tuningMode, "useNNLS", useNNLS); +} +val NNLSChroma::compute(std::vector >& input_logSpectrogram, std::vector& input_meanTuning, std::vector& input_localTuning) { + _nnlschroma->input("logSpectrogram").set(input_logSpectrogram); + _nnlschroma->input("meanTuning").set(input_meanTuning); + _nnlschroma->input("localTuning").set(input_localTuning); + std::vector > output_tunedLogfreqSpectrum; + std::vector > output_semitoneSpectrum; + std::vector > output_bassChromagram; + std::vector > output_chromagram; + _nnlschroma->output("tunedLogfreqSpectrum").set(output_tunedLogfreqSpectrum); + _nnlschroma->output("semitoneSpectrum").set(output_semitoneSpectrum); + _nnlschroma->output("bassChromagram").set(output_bassChromagram); + _nnlschroma->output("chromagram").set(output_chromagram); + _nnlschroma->compute(); + val outputNNLSChroma(val::object()); + outputNNLSChroma.set("tunedLogfreqSpectrum", output_tunedLogfreqSpectrum); + outputNNLSChroma.set("semitoneSpectrum", output_semitoneSpectrum); + outputNNLSChroma.set("bassChromagram", output_bassChromagram); + outputNNLSChroma.set("chromagram", output_chromagram); + return outputNNLSChroma; +} +void NNLSChroma::reset() { +_nnlschroma->reset(); +} +// END NNLSChroma definitions + +// START NoiseAdder definitions // check https://essentia.upf.edu/reference/std_NoiseAdder.html -val EssentiaJS::NoiseAdder(std::vector& input_signal, const bool fixSeed, const int level) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoNoiseAdder = factory.create("NoiseAdder", "fixSeed", fixSeed, "level", level); - algoNoiseAdder->input("signal").set(input_signal); - std::vector output_signal; - algoNoiseAdder->output("signal").set(output_signal); - algoNoiseAdder->compute(); - val outputNoiseAdder(val::object()); - outputNoiseAdder.set("signal", output_signal); - delete algoNoiseAdder; - return outputNoiseAdder; -} - +NoiseAdder::NoiseAdder(const bool fixSeed, const int level) { + configure(fixSeed, level); +} +NoiseAdder::~NoiseAdder() { + delete _noiseadder; +} +void NoiseAdder::configure(const bool fixSeed, const int level) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _noiseadder = factory.create("NoiseAdder", "fixSeed", fixSeed, "level", level); +} +val NoiseAdder::compute(std::vector& input_signal) { + _noiseadder->input("signal").set(input_signal); + std::vector output_signal; + _noiseadder->output("signal").set(output_signal); + _noiseadder->compute(); + val outputNoiseAdder(val::object()); + outputNoiseAdder.set("signal", output_signal); + return outputNoiseAdder; +} +void NoiseAdder::reset() { +_noiseadder->reset(); +} +// END NoiseAdder definitions + +// START NoiseBurstDetector definitions // check https://essentia.upf.edu/reference/std_NoiseBurstDetector.html -val EssentiaJS::NoiseBurstDetector(std::vector& input_frame, const float alpha, const int silenceThreshold, const int threshold) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoNoiseBurstDetector = factory.create("NoiseBurstDetector", "alpha", alpha, "silenceThreshold", silenceThreshold, "threshold", threshold); - algoNoiseBurstDetector->input("frame").set(input_frame); - std::vector output_indexes; - algoNoiseBurstDetector->output("indexes").set(output_indexes); - algoNoiseBurstDetector->compute(); - val outputNoiseBurstDetector(val::object()); - outputNoiseBurstDetector.set("indexes", output_indexes); - delete algoNoiseBurstDetector; - return outputNoiseBurstDetector; -} - +NoiseBurstDetector::NoiseBurstDetector(const float alpha, const int silenceThreshold, const int threshold) { + configure(alpha, silenceThreshold, threshold); +} +NoiseBurstDetector::~NoiseBurstDetector() { + delete _noiseburstdetector; +} +void NoiseBurstDetector::configure(const float alpha, const int silenceThreshold, const int threshold) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _noiseburstdetector = factory.create("NoiseBurstDetector", "alpha", alpha, "silenceThreshold", silenceThreshold, "threshold", threshold); +} +val NoiseBurstDetector::compute(std::vector& input_frame) { + _noiseburstdetector->input("frame").set(input_frame); + std::vector output_indexes; + _noiseburstdetector->output("indexes").set(output_indexes); + _noiseburstdetector->compute(); + val outputNoiseBurstDetector(val::object()); + outputNoiseBurstDetector.set("indexes", output_indexes); + return outputNoiseBurstDetector; +} +void NoiseBurstDetector::reset() { +_noiseburstdetector->reset(); +} +// END NoiseBurstDetector definitions + +// START NoveltyCurve definitions // check https://essentia.upf.edu/reference/std_NoveltyCurve.html -val EssentiaJS::NoveltyCurve(std::vector >& input_frequencyBands, const float frameRate, const bool normalize, const std::vector& weightCurve, const std::string& weightCurveType) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoNoveltyCurve = factory.create("NoveltyCurve", "frameRate", frameRate, "normalize", normalize, "weightCurve", weightCurve, "weightCurveType", weightCurveType); - algoNoveltyCurve->input("frequencyBands").set(input_frequencyBands); - std::vector output_novelty; - algoNoveltyCurve->output("novelty").set(output_novelty); - algoNoveltyCurve->compute(); - val outputNoveltyCurve(val::object()); - outputNoveltyCurve.set("novelty", output_novelty); - delete algoNoveltyCurve; - return outputNoveltyCurve; -} - +NoveltyCurve::NoveltyCurve(const float frameRate, const bool normalize, const std::vector& weightCurve, const std::string& weightCurveType) { + configure(frameRate, normalize, weightCurve, weightCurveType); +} +NoveltyCurve::~NoveltyCurve() { + delete _noveltycurve; +} +void NoveltyCurve::configure(const float frameRate, const bool normalize, const std::vector& weightCurve, const std::string& weightCurveType) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _noveltycurve = factory.create("NoveltyCurve", "frameRate", frameRate, "normalize", normalize, "weightCurve", weightCurve, "weightCurveType", weightCurveType); +} +val NoveltyCurve::compute(std::vector >& input_frequencyBands) { + _noveltycurve->input("frequencyBands").set(input_frequencyBands); + std::vector output_novelty; + _noveltycurve->output("novelty").set(output_novelty); + _noveltycurve->compute(); + val outputNoveltyCurve(val::object()); + outputNoveltyCurve.set("novelty", output_novelty); + return outputNoveltyCurve; +} +void NoveltyCurve::reset() { +_noveltycurve->reset(); +} +// END NoveltyCurve definitions + +// START NoveltyCurveFixedBpmEstimator definitions // check https://essentia.upf.edu/reference/std_NoveltyCurveFixedBpmEstimator.html -val EssentiaJS::NoveltyCurveFixedBpmEstimator(std::vector& input_novelty, const int hopSize, const float maxBpm, const float minBpm, const float sampleRate, const float tolerance) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoNoveltyCurveFixedBpmEstimator = factory.create("NoveltyCurveFixedBpmEstimator", "hopSize", hopSize, "maxBpm", maxBpm, "minBpm", minBpm, "sampleRate", sampleRate, "tolerance", tolerance); - algoNoveltyCurveFixedBpmEstimator->input("novelty").set(input_novelty); - std::vector output_bpms; - std::vector output_amplitudes; - algoNoveltyCurveFixedBpmEstimator->output("bpms").set(output_bpms); - algoNoveltyCurveFixedBpmEstimator->output("amplitudes").set(output_amplitudes); - algoNoveltyCurveFixedBpmEstimator->compute(); - val outputNoveltyCurveFixedBpmEstimator(val::object()); - outputNoveltyCurveFixedBpmEstimator.set("bpms", output_bpms); - outputNoveltyCurveFixedBpmEstimator.set("amplitudes", output_amplitudes); - delete algoNoveltyCurveFixedBpmEstimator; - return outputNoveltyCurveFixedBpmEstimator; -} - +NoveltyCurveFixedBpmEstimator::NoveltyCurveFixedBpmEstimator(const int hopSize, const float maxBpm, const float minBpm, const float sampleRate, const float tolerance) { + configure(hopSize, maxBpm, minBpm, sampleRate, tolerance); +} +NoveltyCurveFixedBpmEstimator::~NoveltyCurveFixedBpmEstimator() { + delete _noveltycurvefixedbpmestimator; +} +void NoveltyCurveFixedBpmEstimator::configure(const int hopSize, const float maxBpm, const float minBpm, const float sampleRate, const float tolerance) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _noveltycurvefixedbpmestimator = factory.create("NoveltyCurveFixedBpmEstimator", "hopSize", hopSize, "maxBpm", maxBpm, "minBpm", minBpm, "sampleRate", sampleRate, "tolerance", tolerance); +} +val NoveltyCurveFixedBpmEstimator::compute(std::vector& input_novelty) { + _noveltycurvefixedbpmestimator->input("novelty").set(input_novelty); + std::vector output_bpms; + std::vector output_amplitudes; + _noveltycurvefixedbpmestimator->output("bpms").set(output_bpms); + _noveltycurvefixedbpmestimator->output("amplitudes").set(output_amplitudes); + _noveltycurvefixedbpmestimator->compute(); + val outputNoveltyCurveFixedBpmEstimator(val::object()); + outputNoveltyCurveFixedBpmEstimator.set("bpms", output_bpms); + outputNoveltyCurveFixedBpmEstimator.set("amplitudes", output_amplitudes); + return outputNoveltyCurveFixedBpmEstimator; +} +void NoveltyCurveFixedBpmEstimator::reset() { +_noveltycurvefixedbpmestimator->reset(); +} +// END NoveltyCurveFixedBpmEstimator definitions + +// START OddToEvenHarmonicEnergyRatio definitions // check https://essentia.upf.edu/reference/std_OddToEvenHarmonicEnergyRatio.html -val EssentiaJS::OddToEvenHarmonicEnergyRatio(std::vector& input_frequencies, std::vector& input_magnitudes) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoOddToEvenHarmonicEnergyRatio = factory.create("OddToEvenHarmonicEnergyRatio"); - algoOddToEvenHarmonicEnergyRatio->input("frequencies").set(input_frequencies); - algoOddToEvenHarmonicEnergyRatio->input("magnitudes").set(input_magnitudes); - float output_oddToEvenHarmonicEnergyRatio; - algoOddToEvenHarmonicEnergyRatio->output("oddToEvenHarmonicEnergyRatio").set(output_oddToEvenHarmonicEnergyRatio); - algoOddToEvenHarmonicEnergyRatio->compute(); - val outputOddToEvenHarmonicEnergyRatio(val::object()); - outputOddToEvenHarmonicEnergyRatio.set("oddToEvenHarmonicEnergyRatio", output_oddToEvenHarmonicEnergyRatio); - delete algoOddToEvenHarmonicEnergyRatio; - return outputOddToEvenHarmonicEnergyRatio; -} - +OddToEvenHarmonicEnergyRatio::OddToEvenHarmonicEnergyRatio() { + configure(); +} +OddToEvenHarmonicEnergyRatio::~OddToEvenHarmonicEnergyRatio() { + delete _oddtoevenharmonicenergyratio; +} +void OddToEvenHarmonicEnergyRatio::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _oddtoevenharmonicenergyratio = factory.create("OddToEvenHarmonicEnergyRatio"); +} +val OddToEvenHarmonicEnergyRatio::compute(std::vector& input_frequencies, std::vector& input_magnitudes) { + _oddtoevenharmonicenergyratio->input("frequencies").set(input_frequencies); + _oddtoevenharmonicenergyratio->input("magnitudes").set(input_magnitudes); + float output_oddToEvenHarmonicEnergyRatio; + _oddtoevenharmonicenergyratio->output("oddToEvenHarmonicEnergyRatio").set(output_oddToEvenHarmonicEnergyRatio); + _oddtoevenharmonicenergyratio->compute(); + val outputOddToEvenHarmonicEnergyRatio(val::object()); + outputOddToEvenHarmonicEnergyRatio.set("oddToEvenHarmonicEnergyRatio", output_oddToEvenHarmonicEnergyRatio); + return outputOddToEvenHarmonicEnergyRatio; +} +void OddToEvenHarmonicEnergyRatio::reset() { +_oddtoevenharmonicenergyratio->reset(); +} +// END OddToEvenHarmonicEnergyRatio definitions + +// START OnsetDetection definitions // check https://essentia.upf.edu/reference/std_OnsetDetection.html -val EssentiaJS::OnsetDetection(std::vector& input_spectrum, std::vector& input_phase, const std::string& method, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoOnsetDetection = factory.create("OnsetDetection", "method", method, "sampleRate", sampleRate); - algoOnsetDetection->input("spectrum").set(input_spectrum); - algoOnsetDetection->input("phase").set(input_phase); - float output_onsetDetection; - algoOnsetDetection->output("onsetDetection").set(output_onsetDetection); - algoOnsetDetection->compute(); - val outputOnsetDetection(val::object()); - outputOnsetDetection.set("onsetDetection", output_onsetDetection); - delete algoOnsetDetection; - return outputOnsetDetection; -} - +OnsetDetection::OnsetDetection(const std::string& method, const float sampleRate) { + configure(method, sampleRate); +} +OnsetDetection::~OnsetDetection() { + delete _onsetdetection; +} +void OnsetDetection::configure(const std::string& method, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _onsetdetection = factory.create("OnsetDetection", "method", method, "sampleRate", sampleRate); +} +val OnsetDetection::compute(std::vector& input_spectrum, std::vector& input_phase) { + _onsetdetection->input("spectrum").set(input_spectrum); + _onsetdetection->input("phase").set(input_phase); + float output_onsetDetection; + _onsetdetection->output("onsetDetection").set(output_onsetDetection); + _onsetdetection->compute(); + val outputOnsetDetection(val::object()); + outputOnsetDetection.set("onsetDetection", output_onsetDetection); + return outputOnsetDetection; +} +void OnsetDetection::reset() { +_onsetdetection->reset(); +} +// END OnsetDetection definitions + +// START OnsetDetectionGlobal definitions // check https://essentia.upf.edu/reference/std_OnsetDetectionGlobal.html -val EssentiaJS::OnsetDetectionGlobal(std::vector& input_signal, const int frameSize, const int hopSize, const std::string& method, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoOnsetDetectionGlobal = factory.create("OnsetDetectionGlobal", "frameSize", frameSize, "hopSize", hopSize, "method", method, "sampleRate", sampleRate); - algoOnsetDetectionGlobal->input("signal").set(input_signal); - std::vector output_onsetDetections; - algoOnsetDetectionGlobal->output("onsetDetections").set(output_onsetDetections); - algoOnsetDetectionGlobal->compute(); - val outputOnsetDetectionGlobal(val::object()); - outputOnsetDetectionGlobal.set("onsetDetections", output_onsetDetections); - delete algoOnsetDetectionGlobal; - return outputOnsetDetectionGlobal; -} - +OnsetDetectionGlobal::OnsetDetectionGlobal(const int frameSize, const int hopSize, const std::string& method, const float sampleRate) { + configure(frameSize, hopSize, method, sampleRate); +} +OnsetDetectionGlobal::~OnsetDetectionGlobal() { + delete _onsetdetectionglobal; +} +void OnsetDetectionGlobal::configure(const int frameSize, const int hopSize, const std::string& method, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _onsetdetectionglobal = factory.create("OnsetDetectionGlobal", "frameSize", frameSize, "hopSize", hopSize, "method", method, "sampleRate", sampleRate); +} +val OnsetDetectionGlobal::compute(std::vector& input_signal) { + _onsetdetectionglobal->input("signal").set(input_signal); + std::vector output_onsetDetections; + _onsetdetectionglobal->output("onsetDetections").set(output_onsetDetections); + _onsetdetectionglobal->compute(); + val outputOnsetDetectionGlobal(val::object()); + outputOnsetDetectionGlobal.set("onsetDetections", output_onsetDetections); + return outputOnsetDetectionGlobal; +} +void OnsetDetectionGlobal::reset() { +_onsetdetectionglobal->reset(); +} +// END OnsetDetectionGlobal definitions + +// START OnsetRate definitions // check https://essentia.upf.edu/reference/std_OnsetRate.html -val EssentiaJS::OnsetRate(std::vector& input_signal) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoOnsetRate = factory.create("OnsetRate"); - algoOnsetRate->input("signal").set(input_signal); - std::vector output_onsets; - float output_onsetRate; - algoOnsetRate->output("onsets").set(output_onsets); - algoOnsetRate->output("onsetRate").set(output_onsetRate); - algoOnsetRate->compute(); - val outputOnsetRate(val::object()); - outputOnsetRate.set("onsets", output_onsets); - outputOnsetRate.set("onsetRate", output_onsetRate); - delete algoOnsetRate; - return outputOnsetRate; -} - +OnsetRate::OnsetRate() { + configure(); +} +OnsetRate::~OnsetRate() { + delete _onsetrate; +} +void OnsetRate::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _onsetrate = factory.create("OnsetRate"); +} +val OnsetRate::compute(std::vector& input_signal) { + _onsetrate->input("signal").set(input_signal); + std::vector output_onsets; + float output_onsetRate; + _onsetrate->output("onsets").set(output_onsets); + _onsetrate->output("onsetRate").set(output_onsetRate); + _onsetrate->compute(); + val outputOnsetRate(val::object()); + outputOnsetRate.set("onsets", output_onsets); + outputOnsetRate.set("onsetRate", output_onsetRate); + return outputOnsetRate; +} +void OnsetRate::reset() { +_onsetrate->reset(); +} +// END OnsetRate definitions + +// START OverlapAdd definitions // check https://essentia.upf.edu/reference/std_OverlapAdd.html -val EssentiaJS::OverlapAdd(std::vector& input_signal, const int frameSize, const float gain, const int hopSize) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoOverlapAdd = factory.create("OverlapAdd", "frameSize", frameSize, "gain", gain, "hopSize", hopSize); - algoOverlapAdd->input("signal").set(input_signal); - std::vector output_signal; - algoOverlapAdd->output("signal").set(output_signal); - algoOverlapAdd->compute(); - val outputOverlapAdd(val::object()); - outputOverlapAdd.set("signal", output_signal); - delete algoOverlapAdd; - return outputOverlapAdd; -} - +OverlapAdd::OverlapAdd(const int frameSize, const float gain, const int hopSize) { + configure(frameSize, gain, hopSize); +} +OverlapAdd::~OverlapAdd() { + delete _overlapadd; +} +void OverlapAdd::configure(const int frameSize, const float gain, const int hopSize) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _overlapadd = factory.create("OverlapAdd", "frameSize", frameSize, "gain", gain, "hopSize", hopSize); +} +val OverlapAdd::compute(std::vector& input_signal) { + _overlapadd->input("signal").set(input_signal); + std::vector output_signal; + _overlapadd->output("signal").set(output_signal); + _overlapadd->compute(); + val outputOverlapAdd(val::object()); + outputOverlapAdd.set("signal", output_signal); + return outputOverlapAdd; +} +void OverlapAdd::reset() { +_overlapadd->reset(); +} +// END OverlapAdd definitions + +// START PeakDetection definitions // check https://essentia.upf.edu/reference/std_PeakDetection.html -val EssentiaJS::PeakDetection(std::vector& input_array, const bool interpolate, const int maxPeaks, const float maxPosition, const float minPeakDistance, const float minPosition, const std::string& orderBy, const float range, const float threshold) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPeakDetection = factory.create("PeakDetection", "interpolate", interpolate, "maxPeaks", maxPeaks, "maxPosition", maxPosition, "minPeakDistance", minPeakDistance, "minPosition", minPosition, "orderBy", orderBy, "range", range, "threshold", threshold); - algoPeakDetection->input("array").set(input_array); - std::vector output_positions; - std::vector output_amplitudes; - algoPeakDetection->output("positions").set(output_positions); - algoPeakDetection->output("amplitudes").set(output_amplitudes); - algoPeakDetection->compute(); - val outputPeakDetection(val::object()); - outputPeakDetection.set("positions", output_positions); - outputPeakDetection.set("amplitudes", output_amplitudes); - delete algoPeakDetection; - return outputPeakDetection; -} - +PeakDetection::PeakDetection(const bool interpolate, const int maxPeaks, const float maxPosition, const float minPeakDistance, const float minPosition, const std::string& orderBy, const float range, const float threshold) { + configure(interpolate, maxPeaks, maxPosition, minPeakDistance, minPosition, orderBy, range, threshold); +} +PeakDetection::~PeakDetection() { + delete _peakdetection; +} +void PeakDetection::configure(const bool interpolate, const int maxPeaks, const float maxPosition, const float minPeakDistance, const float minPosition, const std::string& orderBy, const float range, const float threshold) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _peakdetection = factory.create("PeakDetection", "interpolate", interpolate, "maxPeaks", maxPeaks, "maxPosition", maxPosition, "minPeakDistance", minPeakDistance, "minPosition", minPosition, "orderBy", orderBy, "range", range, "threshold", threshold); +} +val PeakDetection::compute(std::vector& input_array) { + _peakdetection->input("array").set(input_array); + std::vector output_positions; + std::vector output_amplitudes; + _peakdetection->output("positions").set(output_positions); + _peakdetection->output("amplitudes").set(output_amplitudes); + _peakdetection->compute(); + val outputPeakDetection(val::object()); + outputPeakDetection.set("positions", output_positions); + outputPeakDetection.set("amplitudes", output_amplitudes); + return outputPeakDetection; +} +void PeakDetection::reset() { +_peakdetection->reset(); +} +// END PeakDetection definitions + +// START PercivalBpmEstimator definitions // check https://essentia.upf.edu/reference/std_PercivalBpmEstimator.html -val EssentiaJS::PercivalBpmEstimator(std::vector& input_signal, const int frameSize, const int frameSizeOSS, const int hopSize, const int hopSizeOSS, const int maxBPM, const int minBPM, const int sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPercivalBpmEstimator = factory.create("PercivalBpmEstimator", "frameSize", frameSize, "frameSizeOSS", frameSizeOSS, "hopSize", hopSize, "hopSizeOSS", hopSizeOSS, "maxBPM", maxBPM, "minBPM", minBPM, "sampleRate", sampleRate); - algoPercivalBpmEstimator->input("signal").set(input_signal); - float output_bpm; - algoPercivalBpmEstimator->output("bpm").set(output_bpm); - algoPercivalBpmEstimator->compute(); - val outputPercivalBpmEstimator(val::object()); - outputPercivalBpmEstimator.set("bpm", output_bpm); - delete algoPercivalBpmEstimator; - return outputPercivalBpmEstimator; -} - +PercivalBpmEstimator::PercivalBpmEstimator(const int frameSize, const int frameSizeOSS, const int hopSize, const int hopSizeOSS, const int maxBPM, const int minBPM, const int sampleRate) { + configure(frameSize, frameSizeOSS, hopSize, hopSizeOSS, maxBPM, minBPM, sampleRate); +} +PercivalBpmEstimator::~PercivalBpmEstimator() { + delete _percivalbpmestimator; +} +void PercivalBpmEstimator::configure(const int frameSize, const int frameSizeOSS, const int hopSize, const int hopSizeOSS, const int maxBPM, const int minBPM, const int sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _percivalbpmestimator = factory.create("PercivalBpmEstimator", "frameSize", frameSize, "frameSizeOSS", frameSizeOSS, "hopSize", hopSize, "hopSizeOSS", hopSizeOSS, "maxBPM", maxBPM, "minBPM", minBPM, "sampleRate", sampleRate); +} +val PercivalBpmEstimator::compute(std::vector& input_signal) { + _percivalbpmestimator->input("signal").set(input_signal); + float output_bpm; + _percivalbpmestimator->output("bpm").set(output_bpm); + _percivalbpmestimator->compute(); + val outputPercivalBpmEstimator(val::object()); + outputPercivalBpmEstimator.set("bpm", output_bpm); + return outputPercivalBpmEstimator; +} +void PercivalBpmEstimator::reset() { +_percivalbpmestimator->reset(); +} +// END PercivalBpmEstimator definitions + +// START PercivalEnhanceHarmonics definitions // check https://essentia.upf.edu/reference/std_PercivalEnhanceHarmonics.html -val EssentiaJS::PercivalEnhanceHarmonics(std::vector& input_array) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPercivalEnhanceHarmonics = factory.create("PercivalEnhanceHarmonics"); - algoPercivalEnhanceHarmonics->input("array").set(input_array); - std::vector output_array; - algoPercivalEnhanceHarmonics->output("array").set(output_array); - algoPercivalEnhanceHarmonics->compute(); - val outputPercivalEnhanceHarmonics(val::object()); - outputPercivalEnhanceHarmonics.set("array", output_array); - delete algoPercivalEnhanceHarmonics; - return outputPercivalEnhanceHarmonics; -} - +PercivalEnhanceHarmonics::PercivalEnhanceHarmonics() { + configure(); +} +PercivalEnhanceHarmonics::~PercivalEnhanceHarmonics() { + delete _percivalenhanceharmonics; +} +void PercivalEnhanceHarmonics::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _percivalenhanceharmonics = factory.create("PercivalEnhanceHarmonics"); +} +val PercivalEnhanceHarmonics::compute(std::vector& input_array) { + _percivalenhanceharmonics->input("array").set(input_array); + std::vector output_array; + _percivalenhanceharmonics->output("array").set(output_array); + _percivalenhanceharmonics->compute(); + val outputPercivalEnhanceHarmonics(val::object()); + outputPercivalEnhanceHarmonics.set("array", output_array); + return outputPercivalEnhanceHarmonics; +} +void PercivalEnhanceHarmonics::reset() { +_percivalenhanceharmonics->reset(); +} +// END PercivalEnhanceHarmonics definitions + +// START PercivalEvaluatePulseTrains definitions // check https://essentia.upf.edu/reference/std_PercivalEvaluatePulseTrains.html -val EssentiaJS::PercivalEvaluatePulseTrains(std::vector& input_oss, std::vector& input_positions) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPercivalEvaluatePulseTrains = factory.create("PercivalEvaluatePulseTrains"); - algoPercivalEvaluatePulseTrains->input("oss").set(input_oss); - algoPercivalEvaluatePulseTrains->input("positions").set(input_positions); - float output_lag; - algoPercivalEvaluatePulseTrains->output("lag").set(output_lag); - algoPercivalEvaluatePulseTrains->compute(); - val outputPercivalEvaluatePulseTrains(val::object()); - outputPercivalEvaluatePulseTrains.set("lag", output_lag); - delete algoPercivalEvaluatePulseTrains; - return outputPercivalEvaluatePulseTrains; -} - +PercivalEvaluatePulseTrains::PercivalEvaluatePulseTrains() { + configure(); +} +PercivalEvaluatePulseTrains::~PercivalEvaluatePulseTrains() { + delete _percivalevaluatepulsetrains; +} +void PercivalEvaluatePulseTrains::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _percivalevaluatepulsetrains = factory.create("PercivalEvaluatePulseTrains"); +} +val PercivalEvaluatePulseTrains::compute(std::vector& input_oss, std::vector& input_positions) { + _percivalevaluatepulsetrains->input("oss").set(input_oss); + _percivalevaluatepulsetrains->input("positions").set(input_positions); + float output_lag; + _percivalevaluatepulsetrains->output("lag").set(output_lag); + _percivalevaluatepulsetrains->compute(); + val outputPercivalEvaluatePulseTrains(val::object()); + outputPercivalEvaluatePulseTrains.set("lag", output_lag); + return outputPercivalEvaluatePulseTrains; +} +void PercivalEvaluatePulseTrains::reset() { +_percivalevaluatepulsetrains->reset(); +} +// END PercivalEvaluatePulseTrains definitions + +// START PitchContourSegmentation definitions // check https://essentia.upf.edu/reference/std_PitchContourSegmentation.html -val EssentiaJS::PitchContourSegmentation(std::vector& input_pitch, std::vector& input_signal, const int hopSize, const float minDuration, const int pitchDistanceThreshold, const int rmsThreshold, const int sampleRate, const int tuningFrequency) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPitchContourSegmentation = factory.create("PitchContourSegmentation", "hopSize", hopSize, "minDuration", minDuration, "pitchDistanceThreshold", pitchDistanceThreshold, "rmsThreshold", rmsThreshold, "sampleRate", sampleRate, "tuningFrequency", tuningFrequency); - algoPitchContourSegmentation->input("pitch").set(input_pitch); - algoPitchContourSegmentation->input("signal").set(input_signal); - std::vector output_onset; - std::vector output_duration; - std::vector output_MIDIpitch; - algoPitchContourSegmentation->output("onset").set(output_onset); - algoPitchContourSegmentation->output("duration").set(output_duration); - algoPitchContourSegmentation->output("MIDIpitch").set(output_MIDIpitch); - algoPitchContourSegmentation->compute(); - val outputPitchContourSegmentation(val::object()); - outputPitchContourSegmentation.set("onset", output_onset); - outputPitchContourSegmentation.set("duration", output_duration); - outputPitchContourSegmentation.set("MIDIpitch", output_MIDIpitch); - delete algoPitchContourSegmentation; - return outputPitchContourSegmentation; -} - +PitchContourSegmentation::PitchContourSegmentation(const int hopSize, const float minDuration, const int pitchDistanceThreshold, const int rmsThreshold, const int sampleRate, const int tuningFrequency) { + configure(hopSize, minDuration, pitchDistanceThreshold, rmsThreshold, sampleRate, tuningFrequency); +} +PitchContourSegmentation::~PitchContourSegmentation() { + delete _pitchcontoursegmentation; +} +void PitchContourSegmentation::configure(const int hopSize, const float minDuration, const int pitchDistanceThreshold, const int rmsThreshold, const int sampleRate, const int tuningFrequency) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _pitchcontoursegmentation = factory.create("PitchContourSegmentation", "hopSize", hopSize, "minDuration", minDuration, "pitchDistanceThreshold", pitchDistanceThreshold, "rmsThreshold", rmsThreshold, "sampleRate", sampleRate, "tuningFrequency", tuningFrequency); +} +val PitchContourSegmentation::compute(std::vector& input_pitch, std::vector& input_signal) { + _pitchcontoursegmentation->input("pitch").set(input_pitch); + _pitchcontoursegmentation->input("signal").set(input_signal); + std::vector output_onset; + std::vector output_duration; + std::vector output_MIDIpitch; + _pitchcontoursegmentation->output("onset").set(output_onset); + _pitchcontoursegmentation->output("duration").set(output_duration); + _pitchcontoursegmentation->output("MIDIpitch").set(output_MIDIpitch); + _pitchcontoursegmentation->compute(); + val outputPitchContourSegmentation(val::object()); + outputPitchContourSegmentation.set("onset", output_onset); + outputPitchContourSegmentation.set("duration", output_duration); + outputPitchContourSegmentation.set("MIDIpitch", output_MIDIpitch); + return outputPitchContourSegmentation; +} +void PitchContourSegmentation::reset() { +_pitchcontoursegmentation->reset(); +} +// END PitchContourSegmentation definitions + +// START PitchContours definitions // check https://essentia.upf.edu/reference/std_PitchContours.html -val EssentiaJS::PitchContours(std::vector >& input_peakBins, std::vector >& input_peakSaliences, const float binResolution, const int hopSize, const float minDuration, const float peakDistributionThreshold, const float peakFrameThreshold, const float pitchContinuity, const float sampleRate, const float timeContinuity) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPitchContours = factory.create("PitchContours", "binResolution", binResolution, "hopSize", hopSize, "minDuration", minDuration, "peakDistributionThreshold", peakDistributionThreshold, "peakFrameThreshold", peakFrameThreshold, "pitchContinuity", pitchContinuity, "sampleRate", sampleRate, "timeContinuity", timeContinuity); - algoPitchContours->input("peakBins").set(input_peakBins); - algoPitchContours->input("peakSaliences").set(input_peakSaliences); - std::vector > output_contoursBins; - std::vector > output_contoursSaliences; - std::vector output_contoursStartTimes; - float output_duration; - algoPitchContours->output("contoursBins").set(output_contoursBins); - algoPitchContours->output("contoursSaliences").set(output_contoursSaliences); - algoPitchContours->output("contoursStartTimes").set(output_contoursStartTimes); - algoPitchContours->output("duration").set(output_duration); - algoPitchContours->compute(); - val outputPitchContours(val::object()); - outputPitchContours.set("contoursBins", output_contoursBins); - outputPitchContours.set("contoursSaliences", output_contoursSaliences); - outputPitchContours.set("contoursStartTimes", output_contoursStartTimes); - outputPitchContours.set("duration", output_duration); - delete algoPitchContours; - return outputPitchContours; -} - +PitchContours::PitchContours(const float binResolution, const int hopSize, const float minDuration, const float peakDistributionThreshold, const float peakFrameThreshold, const float pitchContinuity, const float sampleRate, const float timeContinuity) { + configure(binResolution, hopSize, minDuration, peakDistributionThreshold, peakFrameThreshold, pitchContinuity, sampleRate, timeContinuity); +} +PitchContours::~PitchContours() { + delete _pitchcontours; +} +void PitchContours::configure(const float binResolution, const int hopSize, const float minDuration, const float peakDistributionThreshold, const float peakFrameThreshold, const float pitchContinuity, const float sampleRate, const float timeContinuity) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _pitchcontours = factory.create("PitchContours", "binResolution", binResolution, "hopSize", hopSize, "minDuration", minDuration, "peakDistributionThreshold", peakDistributionThreshold, "peakFrameThreshold", peakFrameThreshold, "pitchContinuity", pitchContinuity, "sampleRate", sampleRate, "timeContinuity", timeContinuity); +} +val PitchContours::compute(std::vector >& input_peakBins, std::vector >& input_peakSaliences) { + _pitchcontours->input("peakBins").set(input_peakBins); + _pitchcontours->input("peakSaliences").set(input_peakSaliences); + std::vector > output_contoursBins; + std::vector > output_contoursSaliences; + std::vector output_contoursStartTimes; + float output_duration; + _pitchcontours->output("contoursBins").set(output_contoursBins); + _pitchcontours->output("contoursSaliences").set(output_contoursSaliences); + _pitchcontours->output("contoursStartTimes").set(output_contoursStartTimes); + _pitchcontours->output("duration").set(output_duration); + _pitchcontours->compute(); + val outputPitchContours(val::object()); + outputPitchContours.set("contoursBins", output_contoursBins); + outputPitchContours.set("contoursSaliences", output_contoursSaliences); + outputPitchContours.set("contoursStartTimes", output_contoursStartTimes); + outputPitchContours.set("duration", output_duration); + return outputPitchContours; +} +void PitchContours::reset() { +_pitchcontours->reset(); +} +// END PitchContours definitions + +// START PitchContoursMelody definitions // check https://essentia.upf.edu/reference/std_PitchContoursMelody.html -val EssentiaJS::PitchContoursMelody(std::vector >& input_contoursBins, std::vector >& input_contoursSaliences, std::vector& input_contoursStartTimes, float input_duration, const float binResolution, const int filterIterations, const bool guessUnvoiced, const int hopSize, const float maxFrequency, const float minFrequency, const float referenceFrequency, const float sampleRate, const bool voiceVibrato, const float voicingTolerance) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPitchContoursMelody = factory.create("PitchContoursMelody", "binResolution", binResolution, "filterIterations", filterIterations, "guessUnvoiced", guessUnvoiced, "hopSize", hopSize, "maxFrequency", maxFrequency, "minFrequency", minFrequency, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate, "voiceVibrato", voiceVibrato, "voicingTolerance", voicingTolerance); - algoPitchContoursMelody->input("contoursBins").set(input_contoursBins); - algoPitchContoursMelody->input("contoursSaliences").set(input_contoursSaliences); - algoPitchContoursMelody->input("contoursStartTimes").set(input_contoursStartTimes); - algoPitchContoursMelody->input("duration").set(input_duration); - std::vector output_pitch; - std::vector output_pitchConfidence; - algoPitchContoursMelody->output("pitch").set(output_pitch); - algoPitchContoursMelody->output("pitchConfidence").set(output_pitchConfidence); - algoPitchContoursMelody->compute(); - val outputPitchContoursMelody(val::object()); - outputPitchContoursMelody.set("pitch", output_pitch); - outputPitchContoursMelody.set("pitchConfidence", output_pitchConfidence); - delete algoPitchContoursMelody; - return outputPitchContoursMelody; -} - +PitchContoursMelody::PitchContoursMelody(const float binResolution, const int filterIterations, const bool guessUnvoiced, const int hopSize, const float maxFrequency, const float minFrequency, const float referenceFrequency, const float sampleRate, const bool voiceVibrato, const float voicingTolerance) { + configure(binResolution, filterIterations, guessUnvoiced, hopSize, maxFrequency, minFrequency, referenceFrequency, sampleRate, voiceVibrato, voicingTolerance); +} +PitchContoursMelody::~PitchContoursMelody() { + delete _pitchcontoursmelody; +} +void PitchContoursMelody::configure(const float binResolution, const int filterIterations, const bool guessUnvoiced, const int hopSize, const float maxFrequency, const float minFrequency, const float referenceFrequency, const float sampleRate, const bool voiceVibrato, const float voicingTolerance) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _pitchcontoursmelody = factory.create("PitchContoursMelody", "binResolution", binResolution, "filterIterations", filterIterations, "guessUnvoiced", guessUnvoiced, "hopSize", hopSize, "maxFrequency", maxFrequency, "minFrequency", minFrequency, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate, "voiceVibrato", voiceVibrato, "voicingTolerance", voicingTolerance); +} +val PitchContoursMelody::compute(std::vector >& input_contoursBins, std::vector >& input_contoursSaliences, std::vector& input_contoursStartTimes, float input_duration) { + _pitchcontoursmelody->input("contoursBins").set(input_contoursBins); + _pitchcontoursmelody->input("contoursSaliences").set(input_contoursSaliences); + _pitchcontoursmelody->input("contoursStartTimes").set(input_contoursStartTimes); + _pitchcontoursmelody->input("duration").set(input_duration); + std::vector output_pitch; + std::vector output_pitchConfidence; + _pitchcontoursmelody->output("pitch").set(output_pitch); + _pitchcontoursmelody->output("pitchConfidence").set(output_pitchConfidence); + _pitchcontoursmelody->compute(); + val outputPitchContoursMelody(val::object()); + outputPitchContoursMelody.set("pitch", output_pitch); + outputPitchContoursMelody.set("pitchConfidence", output_pitchConfidence); + return outputPitchContoursMelody; +} +void PitchContoursMelody::reset() { +_pitchcontoursmelody->reset(); +} +// END PitchContoursMelody definitions + +// START PitchContoursMonoMelody definitions // check https://essentia.upf.edu/reference/std_PitchContoursMonoMelody.html -val EssentiaJS::PitchContoursMonoMelody(std::vector >& input_contoursBins, std::vector >& input_contoursSaliences, std::vector& input_contoursStartTimes, float input_duration, const float binResolution, const int filterIterations, const bool guessUnvoiced, const int hopSize, const float maxFrequency, const float minFrequency, const float referenceFrequency, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPitchContoursMonoMelody = factory.create("PitchContoursMonoMelody", "binResolution", binResolution, "filterIterations", filterIterations, "guessUnvoiced", guessUnvoiced, "hopSize", hopSize, "maxFrequency", maxFrequency, "minFrequency", minFrequency, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate); - algoPitchContoursMonoMelody->input("contoursBins").set(input_contoursBins); - algoPitchContoursMonoMelody->input("contoursSaliences").set(input_contoursSaliences); - algoPitchContoursMonoMelody->input("contoursStartTimes").set(input_contoursStartTimes); - algoPitchContoursMonoMelody->input("duration").set(input_duration); - std::vector output_pitch; - std::vector output_pitchConfidence; - algoPitchContoursMonoMelody->output("pitch").set(output_pitch); - algoPitchContoursMonoMelody->output("pitchConfidence").set(output_pitchConfidence); - algoPitchContoursMonoMelody->compute(); - val outputPitchContoursMonoMelody(val::object()); - outputPitchContoursMonoMelody.set("pitch", output_pitch); - outputPitchContoursMonoMelody.set("pitchConfidence", output_pitchConfidence); - delete algoPitchContoursMonoMelody; - return outputPitchContoursMonoMelody; -} - +PitchContoursMonoMelody::PitchContoursMonoMelody(const float binResolution, const int filterIterations, const bool guessUnvoiced, const int hopSize, const float maxFrequency, const float minFrequency, const float referenceFrequency, const float sampleRate) { + configure(binResolution, filterIterations, guessUnvoiced, hopSize, maxFrequency, minFrequency, referenceFrequency, sampleRate); +} +PitchContoursMonoMelody::~PitchContoursMonoMelody() { + delete _pitchcontoursmonomelody; +} +void PitchContoursMonoMelody::configure(const float binResolution, const int filterIterations, const bool guessUnvoiced, const int hopSize, const float maxFrequency, const float minFrequency, const float referenceFrequency, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _pitchcontoursmonomelody = factory.create("PitchContoursMonoMelody", "binResolution", binResolution, "filterIterations", filterIterations, "guessUnvoiced", guessUnvoiced, "hopSize", hopSize, "maxFrequency", maxFrequency, "minFrequency", minFrequency, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate); +} +val PitchContoursMonoMelody::compute(std::vector >& input_contoursBins, std::vector >& input_contoursSaliences, std::vector& input_contoursStartTimes, float input_duration) { + _pitchcontoursmonomelody->input("contoursBins").set(input_contoursBins); + _pitchcontoursmonomelody->input("contoursSaliences").set(input_contoursSaliences); + _pitchcontoursmonomelody->input("contoursStartTimes").set(input_contoursStartTimes); + _pitchcontoursmonomelody->input("duration").set(input_duration); + std::vector output_pitch; + std::vector output_pitchConfidence; + _pitchcontoursmonomelody->output("pitch").set(output_pitch); + _pitchcontoursmonomelody->output("pitchConfidence").set(output_pitchConfidence); + _pitchcontoursmonomelody->compute(); + val outputPitchContoursMonoMelody(val::object()); + outputPitchContoursMonoMelody.set("pitch", output_pitch); + outputPitchContoursMonoMelody.set("pitchConfidence", output_pitchConfidence); + return outputPitchContoursMonoMelody; +} +void PitchContoursMonoMelody::reset() { +_pitchcontoursmonomelody->reset(); +} +// END PitchContoursMonoMelody definitions + +// START PitchContoursMultiMelody definitions // check https://essentia.upf.edu/reference/std_PitchContoursMultiMelody.html -val EssentiaJS::PitchContoursMultiMelody(std::vector >& input_contoursBins, std::vector >& input_contoursSaliences, std::vector& input_contoursStartTimes, float input_duration, const float binResolution, const int filterIterations, const bool guessUnvoiced, const int hopSize, const float maxFrequency, const float minFrequency, const float referenceFrequency, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPitchContoursMultiMelody = factory.create("PitchContoursMultiMelody", "binResolution", binResolution, "filterIterations", filterIterations, "guessUnvoiced", guessUnvoiced, "hopSize", hopSize, "maxFrequency", maxFrequency, "minFrequency", minFrequency, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate); - algoPitchContoursMultiMelody->input("contoursBins").set(input_contoursBins); - algoPitchContoursMultiMelody->input("contoursSaliences").set(input_contoursSaliences); - algoPitchContoursMultiMelody->input("contoursStartTimes").set(input_contoursStartTimes); - algoPitchContoursMultiMelody->input("duration").set(input_duration); - std::vector > output_pitch; - algoPitchContoursMultiMelody->output("pitch").set(output_pitch); - algoPitchContoursMultiMelody->compute(); - val outputPitchContoursMultiMelody(val::object()); - outputPitchContoursMultiMelody.set("pitch", output_pitch); - delete algoPitchContoursMultiMelody; - return outputPitchContoursMultiMelody; -} - +PitchContoursMultiMelody::PitchContoursMultiMelody(const float binResolution, const int filterIterations, const bool guessUnvoiced, const int hopSize, const float maxFrequency, const float minFrequency, const float referenceFrequency, const float sampleRate) { + configure(binResolution, filterIterations, guessUnvoiced, hopSize, maxFrequency, minFrequency, referenceFrequency, sampleRate); +} +PitchContoursMultiMelody::~PitchContoursMultiMelody() { + delete _pitchcontoursmultimelody; +} +void PitchContoursMultiMelody::configure(const float binResolution, const int filterIterations, const bool guessUnvoiced, const int hopSize, const float maxFrequency, const float minFrequency, const float referenceFrequency, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _pitchcontoursmultimelody = factory.create("PitchContoursMultiMelody", "binResolution", binResolution, "filterIterations", filterIterations, "guessUnvoiced", guessUnvoiced, "hopSize", hopSize, "maxFrequency", maxFrequency, "minFrequency", minFrequency, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate); +} +val PitchContoursMultiMelody::compute(std::vector >& input_contoursBins, std::vector >& input_contoursSaliences, std::vector& input_contoursStartTimes, float input_duration) { + _pitchcontoursmultimelody->input("contoursBins").set(input_contoursBins); + _pitchcontoursmultimelody->input("contoursSaliences").set(input_contoursSaliences); + _pitchcontoursmultimelody->input("contoursStartTimes").set(input_contoursStartTimes); + _pitchcontoursmultimelody->input("duration").set(input_duration); + std::vector > output_pitch; + _pitchcontoursmultimelody->output("pitch").set(output_pitch); + _pitchcontoursmultimelody->compute(); + val outputPitchContoursMultiMelody(val::object()); + outputPitchContoursMultiMelody.set("pitch", output_pitch); + return outputPitchContoursMultiMelody; +} +void PitchContoursMultiMelody::reset() { +_pitchcontoursmultimelody->reset(); +} +// END PitchContoursMultiMelody definitions + +// START PitchFilter definitions // check https://essentia.upf.edu/reference/std_PitchFilter.html -val EssentiaJS::PitchFilter(std::vector& input_pitch, std::vector& input_pitchConfidence, const int confidenceThreshold, const int minChunkSize, const bool useAbsolutePitchConfidence) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPitchFilter = factory.create("PitchFilter", "confidenceThreshold", confidenceThreshold, "minChunkSize", minChunkSize, "useAbsolutePitchConfidence", useAbsolutePitchConfidence); - algoPitchFilter->input("pitch").set(input_pitch); - algoPitchFilter->input("pitchConfidence").set(input_pitchConfidence); - std::vector output_pitchFiltered; - algoPitchFilter->output("pitchFiltered").set(output_pitchFiltered); - algoPitchFilter->compute(); - val outputPitchFilter(val::object()); - outputPitchFilter.set("pitchFiltered", output_pitchFiltered); - delete algoPitchFilter; - return outputPitchFilter; -} - +PitchFilter::PitchFilter(const int confidenceThreshold, const int minChunkSize, const bool useAbsolutePitchConfidence) { + configure(confidenceThreshold, minChunkSize, useAbsolutePitchConfidence); +} +PitchFilter::~PitchFilter() { + delete _pitchfilter; +} +void PitchFilter::configure(const int confidenceThreshold, const int minChunkSize, const bool useAbsolutePitchConfidence) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _pitchfilter = factory.create("PitchFilter", "confidenceThreshold", confidenceThreshold, "minChunkSize", minChunkSize, "useAbsolutePitchConfidence", useAbsolutePitchConfidence); +} +val PitchFilter::compute(std::vector& input_pitch, std::vector& input_pitchConfidence) { + _pitchfilter->input("pitch").set(input_pitch); + _pitchfilter->input("pitchConfidence").set(input_pitchConfidence); + std::vector output_pitchFiltered; + _pitchfilter->output("pitchFiltered").set(output_pitchFiltered); + _pitchfilter->compute(); + val outputPitchFilter(val::object()); + outputPitchFilter.set("pitchFiltered", output_pitchFiltered); + return outputPitchFilter; +} +void PitchFilter::reset() { +_pitchfilter->reset(); +} +// END PitchFilter definitions + +// START PitchMelodia definitions // check https://essentia.upf.edu/reference/std_PitchMelodia.html -val EssentiaJS::PitchMelodia(std::vector& input_signal, const float binResolution, const int filterIterations, const int frameSize, const bool guessUnvoiced, const float harmonicWeight, const int hopSize, const float magnitudeCompression, const int magnitudeThreshold, const float maxFrequency, const int minDuration, const float minFrequency, const int numberHarmonics, const float peakDistributionThreshold, const float peakFrameThreshold, const float pitchContinuity, const float referenceFrequency, const float sampleRate, const int timeContinuity) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPitchMelodia = factory.create("PitchMelodia", "binResolution", binResolution, "filterIterations", filterIterations, "frameSize", frameSize, "guessUnvoiced", guessUnvoiced, "harmonicWeight", harmonicWeight, "hopSize", hopSize, "magnitudeCompression", magnitudeCompression, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "minDuration", minDuration, "minFrequency", minFrequency, "numberHarmonics", numberHarmonics, "peakDistributionThreshold", peakDistributionThreshold, "peakFrameThreshold", peakFrameThreshold, "pitchContinuity", pitchContinuity, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate, "timeContinuity", timeContinuity); - algoPitchMelodia->input("signal").set(input_signal); - std::vector output_pitch; - std::vector output_pitchConfidence; - algoPitchMelodia->output("pitch").set(output_pitch); - algoPitchMelodia->output("pitchConfidence").set(output_pitchConfidence); - algoPitchMelodia->compute(); - val outputPitchMelodia(val::object()); - outputPitchMelodia.set("pitch", output_pitch); - outputPitchMelodia.set("pitchConfidence", output_pitchConfidence); - delete algoPitchMelodia; - return outputPitchMelodia; -} - +PitchMelodia::PitchMelodia(const float binResolution, const int filterIterations, const int frameSize, const bool guessUnvoiced, const float harmonicWeight, const int hopSize, const float magnitudeCompression, const int magnitudeThreshold, const float maxFrequency, const int minDuration, const float minFrequency, const int numberHarmonics, const float peakDistributionThreshold, const float peakFrameThreshold, const float pitchContinuity, const float referenceFrequency, const float sampleRate, const int timeContinuity) { + configure(binResolution, filterIterations, frameSize, guessUnvoiced, harmonicWeight, hopSize, magnitudeCompression, magnitudeThreshold, maxFrequency, minDuration, minFrequency, numberHarmonics, peakDistributionThreshold, peakFrameThreshold, pitchContinuity, referenceFrequency, sampleRate, timeContinuity); +} +PitchMelodia::~PitchMelodia() { + delete _pitchmelodia; +} +void PitchMelodia::configure(const float binResolution, const int filterIterations, const int frameSize, const bool guessUnvoiced, const float harmonicWeight, const int hopSize, const float magnitudeCompression, const int magnitudeThreshold, const float maxFrequency, const int minDuration, const float minFrequency, const int numberHarmonics, const float peakDistributionThreshold, const float peakFrameThreshold, const float pitchContinuity, const float referenceFrequency, const float sampleRate, const int timeContinuity) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _pitchmelodia = factory.create("PitchMelodia", "binResolution", binResolution, "filterIterations", filterIterations, "frameSize", frameSize, "guessUnvoiced", guessUnvoiced, "harmonicWeight", harmonicWeight, "hopSize", hopSize, "magnitudeCompression", magnitudeCompression, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "minDuration", minDuration, "minFrequency", minFrequency, "numberHarmonics", numberHarmonics, "peakDistributionThreshold", peakDistributionThreshold, "peakFrameThreshold", peakFrameThreshold, "pitchContinuity", pitchContinuity, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate, "timeContinuity", timeContinuity); +} +val PitchMelodia::compute(std::vector& input_signal) { + _pitchmelodia->input("signal").set(input_signal); + std::vector output_pitch; + std::vector output_pitchConfidence; + _pitchmelodia->output("pitch").set(output_pitch); + _pitchmelodia->output("pitchConfidence").set(output_pitchConfidence); + _pitchmelodia->compute(); + val outputPitchMelodia(val::object()); + outputPitchMelodia.set("pitch", output_pitch); + outputPitchMelodia.set("pitchConfidence", output_pitchConfidence); + return outputPitchMelodia; +} +void PitchMelodia::reset() { +_pitchmelodia->reset(); +} +// END PitchMelodia definitions + +// START PitchSalience definitions // check https://essentia.upf.edu/reference/std_PitchSalience.html -val EssentiaJS::PitchSalience(std::vector& input_spectrum, const float highBoundary, const float lowBoundary, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPitchSalience = factory.create("PitchSalience", "highBoundary", highBoundary, "lowBoundary", lowBoundary, "sampleRate", sampleRate); - algoPitchSalience->input("spectrum").set(input_spectrum); - float output_pitchSalience; - algoPitchSalience->output("pitchSalience").set(output_pitchSalience); - algoPitchSalience->compute(); - val outputPitchSalience(val::object()); - outputPitchSalience.set("pitchSalience", output_pitchSalience); - delete algoPitchSalience; - return outputPitchSalience; -} - +PitchSalience::PitchSalience(const float highBoundary, const float lowBoundary, const float sampleRate) { + configure(highBoundary, lowBoundary, sampleRate); +} +PitchSalience::~PitchSalience() { + delete _pitchsalience; +} +void PitchSalience::configure(const float highBoundary, const float lowBoundary, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _pitchsalience = factory.create("PitchSalience", "highBoundary", highBoundary, "lowBoundary", lowBoundary, "sampleRate", sampleRate); +} +val PitchSalience::compute(std::vector& input_spectrum) { + _pitchsalience->input("spectrum").set(input_spectrum); + float output_pitchSalience; + _pitchsalience->output("pitchSalience").set(output_pitchSalience); + _pitchsalience->compute(); + val outputPitchSalience(val::object()); + outputPitchSalience.set("pitchSalience", output_pitchSalience); + return outputPitchSalience; +} +void PitchSalience::reset() { +_pitchsalience->reset(); +} +// END PitchSalience definitions + +// START PitchSalienceFunction definitions // check https://essentia.upf.edu/reference/std_PitchSalienceFunction.html -val EssentiaJS::PitchSalienceFunction(std::vector& input_frequencies, std::vector& input_magnitudes, const float binResolution, const float harmonicWeight, const float magnitudeCompression, const float magnitudeThreshold, const int numberHarmonics, const float referenceFrequency) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPitchSalienceFunction = factory.create("PitchSalienceFunction", "binResolution", binResolution, "harmonicWeight", harmonicWeight, "magnitudeCompression", magnitudeCompression, "magnitudeThreshold", magnitudeThreshold, "numberHarmonics", numberHarmonics, "referenceFrequency", referenceFrequency); - algoPitchSalienceFunction->input("frequencies").set(input_frequencies); - algoPitchSalienceFunction->input("magnitudes").set(input_magnitudes); - std::vector output_salienceFunction; - algoPitchSalienceFunction->output("salienceFunction").set(output_salienceFunction); - algoPitchSalienceFunction->compute(); - val outputPitchSalienceFunction(val::object()); - outputPitchSalienceFunction.set("salienceFunction", output_salienceFunction); - delete algoPitchSalienceFunction; - return outputPitchSalienceFunction; -} - +PitchSalienceFunction::PitchSalienceFunction(const float binResolution, const float harmonicWeight, const float magnitudeCompression, const float magnitudeThreshold, const int numberHarmonics, const float referenceFrequency) { + configure(binResolution, harmonicWeight, magnitudeCompression, magnitudeThreshold, numberHarmonics, referenceFrequency); +} +PitchSalienceFunction::~PitchSalienceFunction() { + delete _pitchsaliencefunction; +} +void PitchSalienceFunction::configure(const float binResolution, const float harmonicWeight, const float magnitudeCompression, const float magnitudeThreshold, const int numberHarmonics, const float referenceFrequency) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _pitchsaliencefunction = factory.create("PitchSalienceFunction", "binResolution", binResolution, "harmonicWeight", harmonicWeight, "magnitudeCompression", magnitudeCompression, "magnitudeThreshold", magnitudeThreshold, "numberHarmonics", numberHarmonics, "referenceFrequency", referenceFrequency); +} +val PitchSalienceFunction::compute(std::vector& input_frequencies, std::vector& input_magnitudes) { + _pitchsaliencefunction->input("frequencies").set(input_frequencies); + _pitchsaliencefunction->input("magnitudes").set(input_magnitudes); + std::vector output_salienceFunction; + _pitchsaliencefunction->output("salienceFunction").set(output_salienceFunction); + _pitchsaliencefunction->compute(); + val outputPitchSalienceFunction(val::object()); + outputPitchSalienceFunction.set("salienceFunction", output_salienceFunction); + return outputPitchSalienceFunction; +} +void PitchSalienceFunction::reset() { +_pitchsaliencefunction->reset(); +} +// END PitchSalienceFunction definitions + +// START PitchSalienceFunctionPeaks definitions // check https://essentia.upf.edu/reference/std_PitchSalienceFunctionPeaks.html -val EssentiaJS::PitchSalienceFunctionPeaks(std::vector& input_salienceFunction, const float binResolution, const float maxFrequency, const float minFrequency, const float referenceFrequency) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPitchSalienceFunctionPeaks = factory.create("PitchSalienceFunctionPeaks", "binResolution", binResolution, "maxFrequency", maxFrequency, "minFrequency", minFrequency, "referenceFrequency", referenceFrequency); - algoPitchSalienceFunctionPeaks->input("salienceFunction").set(input_salienceFunction); - std::vector output_salienceBins; - std::vector output_salienceValues; - algoPitchSalienceFunctionPeaks->output("salienceBins").set(output_salienceBins); - algoPitchSalienceFunctionPeaks->output("salienceValues").set(output_salienceValues); - algoPitchSalienceFunctionPeaks->compute(); - val outputPitchSalienceFunctionPeaks(val::object()); - outputPitchSalienceFunctionPeaks.set("salienceBins", output_salienceBins); - outputPitchSalienceFunctionPeaks.set("salienceValues", output_salienceValues); - delete algoPitchSalienceFunctionPeaks; - return outputPitchSalienceFunctionPeaks; -} - +PitchSalienceFunctionPeaks::PitchSalienceFunctionPeaks(const float binResolution, const float maxFrequency, const float minFrequency, const float referenceFrequency) { + configure(binResolution, maxFrequency, minFrequency, referenceFrequency); +} +PitchSalienceFunctionPeaks::~PitchSalienceFunctionPeaks() { + delete _pitchsaliencefunctionpeaks; +} +void PitchSalienceFunctionPeaks::configure(const float binResolution, const float maxFrequency, const float minFrequency, const float referenceFrequency) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _pitchsaliencefunctionpeaks = factory.create("PitchSalienceFunctionPeaks", "binResolution", binResolution, "maxFrequency", maxFrequency, "minFrequency", minFrequency, "referenceFrequency", referenceFrequency); +} +val PitchSalienceFunctionPeaks::compute(std::vector& input_salienceFunction) { + _pitchsaliencefunctionpeaks->input("salienceFunction").set(input_salienceFunction); + std::vector output_salienceBins; + std::vector output_salienceValues; + _pitchsaliencefunctionpeaks->output("salienceBins").set(output_salienceBins); + _pitchsaliencefunctionpeaks->output("salienceValues").set(output_salienceValues); + _pitchsaliencefunctionpeaks->compute(); + val outputPitchSalienceFunctionPeaks(val::object()); + outputPitchSalienceFunctionPeaks.set("salienceBins", output_salienceBins); + outputPitchSalienceFunctionPeaks.set("salienceValues", output_salienceValues); + return outputPitchSalienceFunctionPeaks; +} +void PitchSalienceFunctionPeaks::reset() { +_pitchsaliencefunctionpeaks->reset(); +} +// END PitchSalienceFunctionPeaks definitions + +// START PitchYin definitions // check https://essentia.upf.edu/reference/std_PitchYin.html -val EssentiaJS::PitchYin(std::vector& input_signal, const int frameSize, const bool interpolate, const float maxFrequency, const float minFrequency, const float sampleRate, const float tolerance) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPitchYin = factory.create("PitchYin", "frameSize", frameSize, "interpolate", interpolate, "maxFrequency", maxFrequency, "minFrequency", minFrequency, "sampleRate", sampleRate, "tolerance", tolerance); - algoPitchYin->input("signal").set(input_signal); - float output_pitch; - float output_pitchConfidence; - algoPitchYin->output("pitch").set(output_pitch); - algoPitchYin->output("pitchConfidence").set(output_pitchConfidence); - algoPitchYin->compute(); - val outputPitchYin(val::object()); - outputPitchYin.set("pitch", output_pitch); - outputPitchYin.set("pitchConfidence", output_pitchConfidence); - delete algoPitchYin; - return outputPitchYin; -} - +PitchYin::PitchYin(const int frameSize, const bool interpolate, const float maxFrequency, const float minFrequency, const float sampleRate, const float tolerance) { + configure(frameSize, interpolate, maxFrequency, minFrequency, sampleRate, tolerance); +} +PitchYin::~PitchYin() { + delete _pitchyin; +} +void PitchYin::configure(const int frameSize, const bool interpolate, const float maxFrequency, const float minFrequency, const float sampleRate, const float tolerance) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _pitchyin = factory.create("PitchYin", "frameSize", frameSize, "interpolate", interpolate, "maxFrequency", maxFrequency, "minFrequency", minFrequency, "sampleRate", sampleRate, "tolerance", tolerance); +} +val PitchYin::compute(std::vector& input_signal) { + _pitchyin->input("signal").set(input_signal); + float output_pitch; + float output_pitchConfidence; + _pitchyin->output("pitch").set(output_pitch); + _pitchyin->output("pitchConfidence").set(output_pitchConfidence); + _pitchyin->compute(); + val outputPitchYin(val::object()); + outputPitchYin.set("pitch", output_pitch); + outputPitchYin.set("pitchConfidence", output_pitchConfidence); + return outputPitchYin; +} +void PitchYin::reset() { +_pitchyin->reset(); +} +// END PitchYin definitions + +// START PitchYinFFT definitions // check https://essentia.upf.edu/reference/std_PitchYinFFT.html -val EssentiaJS::PitchYinFFT(std::vector& input_spectrum, const int frameSize, const bool interpolate, const float maxFrequency, const float minFrequency, const float sampleRate, const float tolerance) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPitchYinFFT = factory.create("PitchYinFFT", "frameSize", frameSize, "interpolate", interpolate, "maxFrequency", maxFrequency, "minFrequency", minFrequency, "sampleRate", sampleRate, "tolerance", tolerance); - algoPitchYinFFT->input("spectrum").set(input_spectrum); - float output_pitch; - float output_pitchConfidence; - algoPitchYinFFT->output("pitch").set(output_pitch); - algoPitchYinFFT->output("pitchConfidence").set(output_pitchConfidence); - algoPitchYinFFT->compute(); - val outputPitchYinFFT(val::object()); - outputPitchYinFFT.set("pitch", output_pitch); - outputPitchYinFFT.set("pitchConfidence", output_pitchConfidence); - delete algoPitchYinFFT; - return outputPitchYinFFT; -} - +PitchYinFFT::PitchYinFFT(const int frameSize, const bool interpolate, const float maxFrequency, const float minFrequency, const float sampleRate, const float tolerance) { + configure(frameSize, interpolate, maxFrequency, minFrequency, sampleRate, tolerance); +} +PitchYinFFT::~PitchYinFFT() { + delete _pitchyinfft; +} +void PitchYinFFT::configure(const int frameSize, const bool interpolate, const float maxFrequency, const float minFrequency, const float sampleRate, const float tolerance) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _pitchyinfft = factory.create("PitchYinFFT", "frameSize", frameSize, "interpolate", interpolate, "maxFrequency", maxFrequency, "minFrequency", minFrequency, "sampleRate", sampleRate, "tolerance", tolerance); +} +val PitchYinFFT::compute(std::vector& input_spectrum) { + _pitchyinfft->input("spectrum").set(input_spectrum); + float output_pitch; + float output_pitchConfidence; + _pitchyinfft->output("pitch").set(output_pitch); + _pitchyinfft->output("pitchConfidence").set(output_pitchConfidence); + _pitchyinfft->compute(); + val outputPitchYinFFT(val::object()); + outputPitchYinFFT.set("pitch", output_pitch); + outputPitchYinFFT.set("pitchConfidence", output_pitchConfidence); + return outputPitchYinFFT; +} +void PitchYinFFT::reset() { +_pitchyinfft->reset(); +} +// END PitchYinFFT definitions + +// START PitchYinProbabilistic definitions // check https://essentia.upf.edu/reference/std_PitchYinProbabilistic.html -val EssentiaJS::PitchYinProbabilistic(std::vector& input_signal, const int frameSize, const int hopSize, const float lowRMSThreshold, const std::string& outputUnvoiced, const bool preciseTime, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPitchYinProbabilistic = factory.create("PitchYinProbabilistic", "frameSize", frameSize, "hopSize", hopSize, "lowRMSThreshold", lowRMSThreshold, "outputUnvoiced", outputUnvoiced, "preciseTime", preciseTime, "sampleRate", sampleRate); - algoPitchYinProbabilistic->input("signal").set(input_signal); - std::vector output_pitch; - std::vector output_voicedProbabilities; - algoPitchYinProbabilistic->output("pitch").set(output_pitch); - algoPitchYinProbabilistic->output("voicedProbabilities").set(output_voicedProbabilities); - algoPitchYinProbabilistic->compute(); - val outputPitchYinProbabilistic(val::object()); - outputPitchYinProbabilistic.set("pitch", output_pitch); - outputPitchYinProbabilistic.set("voicedProbabilities", output_voicedProbabilities); - delete algoPitchYinProbabilistic; - return outputPitchYinProbabilistic; -} - +PitchYinProbabilistic::PitchYinProbabilistic(const int frameSize, const int hopSize, const float lowRMSThreshold, const std::string& outputUnvoiced, const bool preciseTime, const float sampleRate) { + configure(frameSize, hopSize, lowRMSThreshold, outputUnvoiced, preciseTime, sampleRate); +} +PitchYinProbabilistic::~PitchYinProbabilistic() { + delete _pitchyinprobabilistic; +} +void PitchYinProbabilistic::configure(const int frameSize, const int hopSize, const float lowRMSThreshold, const std::string& outputUnvoiced, const bool preciseTime, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _pitchyinprobabilistic = factory.create("PitchYinProbabilistic", "frameSize", frameSize, "hopSize", hopSize, "lowRMSThreshold", lowRMSThreshold, "outputUnvoiced", outputUnvoiced, "preciseTime", preciseTime, "sampleRate", sampleRate); +} +val PitchYinProbabilistic::compute(std::vector& input_signal) { + _pitchyinprobabilistic->input("signal").set(input_signal); + std::vector output_pitch; + std::vector output_voicedProbabilities; + _pitchyinprobabilistic->output("pitch").set(output_pitch); + _pitchyinprobabilistic->output("voicedProbabilities").set(output_voicedProbabilities); + _pitchyinprobabilistic->compute(); + val outputPitchYinProbabilistic(val::object()); + outputPitchYinProbabilistic.set("pitch", output_pitch); + outputPitchYinProbabilistic.set("voicedProbabilities", output_voicedProbabilities); + return outputPitchYinProbabilistic; +} +void PitchYinProbabilistic::reset() { +_pitchyinprobabilistic->reset(); +} +// END PitchYinProbabilistic definitions + +// START PitchYinProbabilities definitions // check https://essentia.upf.edu/reference/std_PitchYinProbabilities.html -val EssentiaJS::PitchYinProbabilities(std::vector& input_signal, const int frameSize, const float lowAmp, const bool preciseTime, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPitchYinProbabilities = factory.create("PitchYinProbabilities", "frameSize", frameSize, "lowAmp", lowAmp, "preciseTime", preciseTime, "sampleRate", sampleRate); - algoPitchYinProbabilities->input("signal").set(input_signal); - std::vector output_pitch; - std::vector output_probabilities; - float output_RMS; - algoPitchYinProbabilities->output("pitch").set(output_pitch); - algoPitchYinProbabilities->output("probabilities").set(output_probabilities); - algoPitchYinProbabilities->output("RMS").set(output_RMS); - algoPitchYinProbabilities->compute(); - val outputPitchYinProbabilities(val::object()); - outputPitchYinProbabilities.set("pitch", output_pitch); - outputPitchYinProbabilities.set("probabilities", output_probabilities); - outputPitchYinProbabilities.set("RMS", output_RMS); - delete algoPitchYinProbabilities; - return outputPitchYinProbabilities; -} - +PitchYinProbabilities::PitchYinProbabilities(const int frameSize, const float lowAmp, const bool preciseTime, const float sampleRate) { + configure(frameSize, lowAmp, preciseTime, sampleRate); +} +PitchYinProbabilities::~PitchYinProbabilities() { + delete _pitchyinprobabilities; +} +void PitchYinProbabilities::configure(const int frameSize, const float lowAmp, const bool preciseTime, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _pitchyinprobabilities = factory.create("PitchYinProbabilities", "frameSize", frameSize, "lowAmp", lowAmp, "preciseTime", preciseTime, "sampleRate", sampleRate); +} +val PitchYinProbabilities::compute(std::vector& input_signal) { + _pitchyinprobabilities->input("signal").set(input_signal); + std::vector output_pitch; + std::vector output_probabilities; + float output_RMS; + _pitchyinprobabilities->output("pitch").set(output_pitch); + _pitchyinprobabilities->output("probabilities").set(output_probabilities); + _pitchyinprobabilities->output("RMS").set(output_RMS); + _pitchyinprobabilities->compute(); + val outputPitchYinProbabilities(val::object()); + outputPitchYinProbabilities.set("pitch", output_pitch); + outputPitchYinProbabilities.set("probabilities", output_probabilities); + outputPitchYinProbabilities.set("RMS", output_RMS); + return outputPitchYinProbabilities; +} +void PitchYinProbabilities::reset() { +_pitchyinprobabilities->reset(); +} +// END PitchYinProbabilities definitions + +// START PitchYinProbabilitiesHMM definitions // check https://essentia.upf.edu/reference/std_PitchYinProbabilitiesHMM.html -val EssentiaJS::PitchYinProbabilitiesHMM(std::vector >& input_pitchCandidates, std::vector >& input_probabilities, const float minFrequency, const int numberBinsPerSemitone, const float selfTransition, const float yinTrust) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPitchYinProbabilitiesHMM = factory.create("PitchYinProbabilitiesHMM", "minFrequency", minFrequency, "numberBinsPerSemitone", numberBinsPerSemitone, "selfTransition", selfTransition, "yinTrust", yinTrust); - algoPitchYinProbabilitiesHMM->input("pitchCandidates").set(input_pitchCandidates); - algoPitchYinProbabilitiesHMM->input("probabilities").set(input_probabilities); - std::vector output_pitch; - algoPitchYinProbabilitiesHMM->output("pitch").set(output_pitch); - algoPitchYinProbabilitiesHMM->compute(); - val outputPitchYinProbabilitiesHMM(val::object()); - outputPitchYinProbabilitiesHMM.set("pitch", output_pitch); - delete algoPitchYinProbabilitiesHMM; - return outputPitchYinProbabilitiesHMM; -} - +PitchYinProbabilitiesHMM::PitchYinProbabilitiesHMM(const float minFrequency, const int numberBinsPerSemitone, const float selfTransition, const float yinTrust) { + configure(minFrequency, numberBinsPerSemitone, selfTransition, yinTrust); +} +PitchYinProbabilitiesHMM::~PitchYinProbabilitiesHMM() { + delete _pitchyinprobabilitieshmm; +} +void PitchYinProbabilitiesHMM::configure(const float minFrequency, const int numberBinsPerSemitone, const float selfTransition, const float yinTrust) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _pitchyinprobabilitieshmm = factory.create("PitchYinProbabilitiesHMM", "minFrequency", minFrequency, "numberBinsPerSemitone", numberBinsPerSemitone, "selfTransition", selfTransition, "yinTrust", yinTrust); +} +val PitchYinProbabilitiesHMM::compute(std::vector >& input_pitchCandidates, std::vector >& input_probabilities) { + _pitchyinprobabilitieshmm->input("pitchCandidates").set(input_pitchCandidates); + _pitchyinprobabilitieshmm->input("probabilities").set(input_probabilities); + std::vector output_pitch; + _pitchyinprobabilitieshmm->output("pitch").set(output_pitch); + _pitchyinprobabilitieshmm->compute(); + val outputPitchYinProbabilitiesHMM(val::object()); + outputPitchYinProbabilitiesHMM.set("pitch", output_pitch); + return outputPitchYinProbabilitiesHMM; +} +void PitchYinProbabilitiesHMM::reset() { +_pitchyinprobabilitieshmm->reset(); +} +// END PitchYinProbabilitiesHMM definitions + +// START PowerMean definitions // check https://essentia.upf.edu/reference/std_PowerMean.html -val EssentiaJS::PowerMean(std::vector& input_array, const float power) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPowerMean = factory.create("PowerMean", "power", power); - algoPowerMean->input("array").set(input_array); - float output_powerMean; - algoPowerMean->output("powerMean").set(output_powerMean); - algoPowerMean->compute(); - val outputPowerMean(val::object()); - outputPowerMean.set("powerMean", output_powerMean); - delete algoPowerMean; - return outputPowerMean; -} - +PowerMean::PowerMean(const float power) { + configure(power); +} +PowerMean::~PowerMean() { + delete _powermean; +} +void PowerMean::configure(const float power) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _powermean = factory.create("PowerMean", "power", power); +} +val PowerMean::compute(std::vector& input_array) { + _powermean->input("array").set(input_array); + float output_powerMean; + _powermean->output("powerMean").set(output_powerMean); + _powermean->compute(); + val outputPowerMean(val::object()); + outputPowerMean.set("powerMean", output_powerMean); + return outputPowerMean; +} +void PowerMean::reset() { +_powermean->reset(); +} +// END PowerMean definitions + +// START PowerSpectrum definitions // check https://essentia.upf.edu/reference/std_PowerSpectrum.html -val EssentiaJS::PowerSpectrum(std::vector& input_signal, const int size) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPowerSpectrum = factory.create("PowerSpectrum", "size", size); - algoPowerSpectrum->input("signal").set(input_signal); - std::vector output_powerSpectrum; - algoPowerSpectrum->output("powerSpectrum").set(output_powerSpectrum); - algoPowerSpectrum->compute(); - val outputPowerSpectrum(val::object()); - outputPowerSpectrum.set("powerSpectrum", output_powerSpectrum); - delete algoPowerSpectrum; - return outputPowerSpectrum; -} - +PowerSpectrum::PowerSpectrum(const int size) { + configure(size); +} +PowerSpectrum::~PowerSpectrum() { + delete _powerspectrum; +} +void PowerSpectrum::configure(const int size) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _powerspectrum = factory.create("PowerSpectrum", "size", size); +} +val PowerSpectrum::compute(std::vector& input_signal) { + _powerspectrum->input("signal").set(input_signal); + std::vector output_powerSpectrum; + _powerspectrum->output("powerSpectrum").set(output_powerSpectrum); + _powerspectrum->compute(); + val outputPowerSpectrum(val::object()); + outputPowerSpectrum.set("powerSpectrum", output_powerSpectrum); + return outputPowerSpectrum; +} +void PowerSpectrum::reset() { +_powerspectrum->reset(); +} +// END PowerSpectrum definitions + +// START PredominantPitchMelodia definitions // check https://essentia.upf.edu/reference/std_PredominantPitchMelodia.html -val EssentiaJS::PredominantPitchMelodia(std::vector& input_signal, const float binResolution, const int filterIterations, const int frameSize, const bool guessUnvoiced, const float harmonicWeight, const int hopSize, const float magnitudeCompression, const int magnitudeThreshold, const float maxFrequency, const int minDuration, const float minFrequency, const int numberHarmonics, const float peakDistributionThreshold, const float peakFrameThreshold, const float pitchContinuity, const float referenceFrequency, const float sampleRate, const int timeContinuity, const bool voiceVibrato, const float voicingTolerance) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoPredominantPitchMelodia = factory.create("PredominantPitchMelodia", "binResolution", binResolution, "filterIterations", filterIterations, "frameSize", frameSize, "guessUnvoiced", guessUnvoiced, "harmonicWeight", harmonicWeight, "hopSize", hopSize, "magnitudeCompression", magnitudeCompression, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "minDuration", minDuration, "minFrequency", minFrequency, "numberHarmonics", numberHarmonics, "peakDistributionThreshold", peakDistributionThreshold, "peakFrameThreshold", peakFrameThreshold, "pitchContinuity", pitchContinuity, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate, "timeContinuity", timeContinuity, "voiceVibrato", voiceVibrato, "voicingTolerance", voicingTolerance); - algoPredominantPitchMelodia->input("signal").set(input_signal); - std::vector output_pitch; - std::vector output_pitchConfidence; - algoPredominantPitchMelodia->output("pitch").set(output_pitch); - algoPredominantPitchMelodia->output("pitchConfidence").set(output_pitchConfidence); - algoPredominantPitchMelodia->compute(); - val outputPredominantPitchMelodia(val::object()); - outputPredominantPitchMelodia.set("pitch", output_pitch); - outputPredominantPitchMelodia.set("pitchConfidence", output_pitchConfidence); - delete algoPredominantPitchMelodia; - return outputPredominantPitchMelodia; -} - +PredominantPitchMelodia::PredominantPitchMelodia(const float binResolution, const int filterIterations, const int frameSize, const bool guessUnvoiced, const float harmonicWeight, const int hopSize, const float magnitudeCompression, const int magnitudeThreshold, const float maxFrequency, const int minDuration, const float minFrequency, const int numberHarmonics, const float peakDistributionThreshold, const float peakFrameThreshold, const float pitchContinuity, const float referenceFrequency, const float sampleRate, const int timeContinuity, const bool voiceVibrato, const float voicingTolerance) { + configure(binResolution, filterIterations, frameSize, guessUnvoiced, harmonicWeight, hopSize, magnitudeCompression, magnitudeThreshold, maxFrequency, minDuration, minFrequency, numberHarmonics, peakDistributionThreshold, peakFrameThreshold, pitchContinuity, referenceFrequency, sampleRate, timeContinuity, voiceVibrato, voicingTolerance); +} +PredominantPitchMelodia::~PredominantPitchMelodia() { + delete _predominantpitchmelodia; +} +void PredominantPitchMelodia::configure(const float binResolution, const int filterIterations, const int frameSize, const bool guessUnvoiced, const float harmonicWeight, const int hopSize, const float magnitudeCompression, const int magnitudeThreshold, const float maxFrequency, const int minDuration, const float minFrequency, const int numberHarmonics, const float peakDistributionThreshold, const float peakFrameThreshold, const float pitchContinuity, const float referenceFrequency, const float sampleRate, const int timeContinuity, const bool voiceVibrato, const float voicingTolerance) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _predominantpitchmelodia = factory.create("PredominantPitchMelodia", "binResolution", binResolution, "filterIterations", filterIterations, "frameSize", frameSize, "guessUnvoiced", guessUnvoiced, "harmonicWeight", harmonicWeight, "hopSize", hopSize, "magnitudeCompression", magnitudeCompression, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "minDuration", minDuration, "minFrequency", minFrequency, "numberHarmonics", numberHarmonics, "peakDistributionThreshold", peakDistributionThreshold, "peakFrameThreshold", peakFrameThreshold, "pitchContinuity", pitchContinuity, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate, "timeContinuity", timeContinuity, "voiceVibrato", voiceVibrato, "voicingTolerance", voicingTolerance); +} +val PredominantPitchMelodia::compute(std::vector& input_signal) { + _predominantpitchmelodia->input("signal").set(input_signal); + std::vector output_pitch; + std::vector output_pitchConfidence; + _predominantpitchmelodia->output("pitch").set(output_pitch); + _predominantpitchmelodia->output("pitchConfidence").set(output_pitchConfidence); + _predominantpitchmelodia->compute(); + val outputPredominantPitchMelodia(val::object()); + outputPredominantPitchMelodia.set("pitch", output_pitch); + outputPredominantPitchMelodia.set("pitchConfidence", output_pitchConfidence); + return outputPredominantPitchMelodia; +} +void PredominantPitchMelodia::reset() { +_predominantpitchmelodia->reset(); +} +// END PredominantPitchMelodia definitions + +// START RMS definitions // check https://essentia.upf.edu/reference/std_RMS.html -val EssentiaJS::RMS(std::vector& input_array) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoRMS = factory.create("RMS"); - algoRMS->input("array").set(input_array); - float output_rms; - algoRMS->output("rms").set(output_rms); - algoRMS->compute(); - val outputRMS(val::object()); - outputRMS.set("rms", output_rms); - delete algoRMS; - return outputRMS; -} - +RMS::RMS() { + configure(); +} +RMS::~RMS() { + delete _rms; +} +void RMS::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _rms = factory.create("RMS"); +} +val RMS::compute(std::vector& input_array) { + _rms->input("array").set(input_array); + float output_rms; + _rms->output("rms").set(output_rms); + _rms->compute(); + val outputRMS(val::object()); + outputRMS.set("rms", output_rms); + return outputRMS; +} +void RMS::reset() { +_rms->reset(); +} +// END RMS definitions + +// START RawMoments definitions // check https://essentia.upf.edu/reference/std_RawMoments.html -val EssentiaJS::RawMoments(std::vector& input_array, const float range) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoRawMoments = factory.create("RawMoments", "range", range); - algoRawMoments->input("array").set(input_array); - std::vector output_rawMoments; - algoRawMoments->output("rawMoments").set(output_rawMoments); - algoRawMoments->compute(); - val outputRawMoments(val::object()); - outputRawMoments.set("rawMoments", output_rawMoments); - delete algoRawMoments; - return outputRawMoments; -} - +RawMoments::RawMoments(const float range) { + configure(range); +} +RawMoments::~RawMoments() { + delete _rawmoments; +} +void RawMoments::configure(const float range) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _rawmoments = factory.create("RawMoments", "range", range); +} +val RawMoments::compute(std::vector& input_array) { + _rawmoments->input("array").set(input_array); + std::vector output_rawMoments; + _rawmoments->output("rawMoments").set(output_rawMoments); + _rawmoments->compute(); + val outputRawMoments(val::object()); + outputRawMoments.set("rawMoments", output_rawMoments); + return outputRawMoments; +} +void RawMoments::reset() { +_rawmoments->reset(); +} +// END RawMoments definitions + +// START ReplayGain definitions // check https://essentia.upf.edu/reference/std_ReplayGain.html -val EssentiaJS::ReplayGain(std::vector& input_signal, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoReplayGain = factory.create("ReplayGain", "sampleRate", sampleRate); - algoReplayGain->input("signal").set(input_signal); - float output_replayGain; - algoReplayGain->output("replayGain").set(output_replayGain); - algoReplayGain->compute(); - val outputReplayGain(val::object()); - outputReplayGain.set("replayGain", output_replayGain); - delete algoReplayGain; - return outputReplayGain; -} - +ReplayGain::ReplayGain(const float sampleRate) { + configure(sampleRate); +} +ReplayGain::~ReplayGain() { + delete _replaygain; +} +void ReplayGain::configure(const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _replaygain = factory.create("ReplayGain", "sampleRate", sampleRate); +} +val ReplayGain::compute(std::vector& input_signal) { + _replaygain->input("signal").set(input_signal); + float output_replayGain; + _replaygain->output("replayGain").set(output_replayGain); + _replaygain->compute(); + val outputReplayGain(val::object()); + outputReplayGain.set("replayGain", output_replayGain); + return outputReplayGain; +} +void ReplayGain::reset() { +_replaygain->reset(); +} +// END ReplayGain definitions + +// START Resample definitions // check https://essentia.upf.edu/reference/std_Resample.html -val EssentiaJS::Resample(std::vector& input_signal, const float inputSampleRate, const float outputSampleRate, const int quality) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoResample = factory.create("Resample", "inputSampleRate", inputSampleRate, "outputSampleRate", outputSampleRate, "quality", quality); - algoResample->input("signal").set(input_signal); - std::vector output_signal; - algoResample->output("signal").set(output_signal); - algoResample->compute(); - val outputResample(val::object()); - outputResample.set("signal", output_signal); - delete algoResample; - return outputResample; -} - +Resample::Resample(const float inputSampleRate, const float outputSampleRate, const int quality) { + configure(inputSampleRate, outputSampleRate, quality); +} +Resample::~Resample() { + delete _resample; +} +void Resample::configure(const float inputSampleRate, const float outputSampleRate, const int quality) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _resample = factory.create("Resample", "inputSampleRate", inputSampleRate, "outputSampleRate", outputSampleRate, "quality", quality); +} +val Resample::compute(std::vector& input_signal) { + _resample->input("signal").set(input_signal); + std::vector output_signal; + _resample->output("signal").set(output_signal); + _resample->compute(); + val outputResample(val::object()); + outputResample.set("signal", output_signal); + return outputResample; +} +void Resample::reset() { +_resample->reset(); +} +// END Resample definitions + +// START ResampleFFT definitions // check https://essentia.upf.edu/reference/std_ResampleFFT.html -val EssentiaJS::ResampleFFT(std::vector& input_input, const int inSize, const int outSize) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoResampleFFT = factory.create("ResampleFFT", "inSize", inSize, "outSize", outSize); - algoResampleFFT->input("input").set(input_input); - std::vector output_output; - algoResampleFFT->output("output").set(output_output); - algoResampleFFT->compute(); - val outputResampleFFT(val::object()); - outputResampleFFT.set("output", output_output); - delete algoResampleFFT; - return outputResampleFFT; -} - +ResampleFFT::ResampleFFT(const int inSize, const int outSize) { + configure(inSize, outSize); +} +ResampleFFT::~ResampleFFT() { + delete _resamplefft; +} +void ResampleFFT::configure(const int inSize, const int outSize) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _resamplefft = factory.create("ResampleFFT", "inSize", inSize, "outSize", outSize); +} +val ResampleFFT::compute(std::vector& input_input) { + _resamplefft->input("input").set(input_input); + std::vector output_output; + _resamplefft->output("output").set(output_output); + _resamplefft->compute(); + val outputResampleFFT(val::object()); + outputResampleFFT.set("output", output_output); + return outputResampleFFT; +} +void ResampleFFT::reset() { +_resamplefft->reset(); +} +// END ResampleFFT definitions + +// START RhythmDescriptors definitions // check https://essentia.upf.edu/reference/std_RhythmDescriptors.html -val EssentiaJS::RhythmDescriptors(std::vector& input_signal) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoRhythmDescriptors = factory.create("RhythmDescriptors"); - algoRhythmDescriptors->input("signal").set(input_signal); - std::vector output_beats_position; - float output_confidence; - float output_bpm; - std::vector output_bpm_estimates; - std::vector output_bpm_intervals; - float output_first_peak_bpm; - float output_first_peak_spread; - float output_first_peak_weight; - float output_second_peak_bpm; - float output_second_peak_spread; - float output_second_peak_weight; - std::vector output_histogram; - algoRhythmDescriptors->output("beats_position").set(output_beats_position); - algoRhythmDescriptors->output("confidence").set(output_confidence); - algoRhythmDescriptors->output("bpm").set(output_bpm); - algoRhythmDescriptors->output("bpm_estimates").set(output_bpm_estimates); - algoRhythmDescriptors->output("bpm_intervals").set(output_bpm_intervals); - algoRhythmDescriptors->output("first_peak_bpm").set(output_first_peak_bpm); - algoRhythmDescriptors->output("first_peak_spread").set(output_first_peak_spread); - algoRhythmDescriptors->output("first_peak_weight").set(output_first_peak_weight); - algoRhythmDescriptors->output("second_peak_bpm").set(output_second_peak_bpm); - algoRhythmDescriptors->output("second_peak_spread").set(output_second_peak_spread); - algoRhythmDescriptors->output("second_peak_weight").set(output_second_peak_weight); - algoRhythmDescriptors->output("histogram").set(output_histogram); - algoRhythmDescriptors->compute(); - val outputRhythmDescriptors(val::object()); - outputRhythmDescriptors.set("beats_position", output_beats_position); - outputRhythmDescriptors.set("confidence", output_confidence); - outputRhythmDescriptors.set("bpm", output_bpm); - outputRhythmDescriptors.set("bpm_estimates", output_bpm_estimates); - outputRhythmDescriptors.set("bpm_intervals", output_bpm_intervals); - outputRhythmDescriptors.set("first_peak_bpm", output_first_peak_bpm); - outputRhythmDescriptors.set("first_peak_spread", output_first_peak_spread); - outputRhythmDescriptors.set("first_peak_weight", output_first_peak_weight); - outputRhythmDescriptors.set("second_peak_bpm", output_second_peak_bpm); - outputRhythmDescriptors.set("second_peak_spread", output_second_peak_spread); - outputRhythmDescriptors.set("second_peak_weight", output_second_peak_weight); - outputRhythmDescriptors.set("histogram", output_histogram); - delete algoRhythmDescriptors; - return outputRhythmDescriptors; -} - +RhythmDescriptors::RhythmDescriptors() { + configure(); +} +RhythmDescriptors::~RhythmDescriptors() { + delete _rhythmdescriptors; +} +void RhythmDescriptors::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _rhythmdescriptors = factory.create("RhythmDescriptors"); +} +val RhythmDescriptors::compute(std::vector& input_signal) { + _rhythmdescriptors->input("signal").set(input_signal); + std::vector output_beats_position; + float output_confidence; + float output_bpm; + std::vector output_bpm_estimates; + std::vector output_bpm_intervals; + float output_first_peak_bpm; + float output_first_peak_spread; + float output_first_peak_weight; + float output_second_peak_bpm; + float output_second_peak_spread; + float output_second_peak_weight; + std::vector output_histogram; + _rhythmdescriptors->output("beats_position").set(output_beats_position); + _rhythmdescriptors->output("confidence").set(output_confidence); + _rhythmdescriptors->output("bpm").set(output_bpm); + _rhythmdescriptors->output("bpm_estimates").set(output_bpm_estimates); + _rhythmdescriptors->output("bpm_intervals").set(output_bpm_intervals); + _rhythmdescriptors->output("first_peak_bpm").set(output_first_peak_bpm); + _rhythmdescriptors->output("first_peak_spread").set(output_first_peak_spread); + _rhythmdescriptors->output("first_peak_weight").set(output_first_peak_weight); + _rhythmdescriptors->output("second_peak_bpm").set(output_second_peak_bpm); + _rhythmdescriptors->output("second_peak_spread").set(output_second_peak_spread); + _rhythmdescriptors->output("second_peak_weight").set(output_second_peak_weight); + _rhythmdescriptors->output("histogram").set(output_histogram); + _rhythmdescriptors->compute(); + val outputRhythmDescriptors(val::object()); + outputRhythmDescriptors.set("beats_position", output_beats_position); + outputRhythmDescriptors.set("confidence", output_confidence); + outputRhythmDescriptors.set("bpm", output_bpm); + outputRhythmDescriptors.set("bpm_estimates", output_bpm_estimates); + outputRhythmDescriptors.set("bpm_intervals", output_bpm_intervals); + outputRhythmDescriptors.set("first_peak_bpm", output_first_peak_bpm); + outputRhythmDescriptors.set("first_peak_spread", output_first_peak_spread); + outputRhythmDescriptors.set("first_peak_weight", output_first_peak_weight); + outputRhythmDescriptors.set("second_peak_bpm", output_second_peak_bpm); + outputRhythmDescriptors.set("second_peak_spread", output_second_peak_spread); + outputRhythmDescriptors.set("second_peak_weight", output_second_peak_weight); + outputRhythmDescriptors.set("histogram", output_histogram); + return outputRhythmDescriptors; +} +void RhythmDescriptors::reset() { +_rhythmdescriptors->reset(); +} +// END RhythmDescriptors definitions + +// START RhythmExtractor definitions // check https://essentia.upf.edu/reference/std_RhythmExtractor.html -val EssentiaJS::RhythmExtractor(std::vector& input_signal, const int frameHop, const int frameSize, const int hopSize, const float lastBeatInterval, const int maxTempo, const int minTempo, const int numberFrames, const float sampleRate, const std::vector& tempoHints, const float tolerance, const bool useBands, const bool useOnset) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoRhythmExtractor = factory.create("RhythmExtractor", "frameHop", frameHop, "frameSize", frameSize, "hopSize", hopSize, "lastBeatInterval", lastBeatInterval, "maxTempo", maxTempo, "minTempo", minTempo, "numberFrames", numberFrames, "sampleRate", sampleRate, "tempoHints", tempoHints, "tolerance", tolerance, "useBands", useBands, "useOnset", useOnset); - algoRhythmExtractor->input("signal").set(input_signal); - float output_bpm; - std::vector output_ticks; - std::vector output_estimates; - std::vector output_bpmIntervals; - algoRhythmExtractor->output("bpm").set(output_bpm); - algoRhythmExtractor->output("ticks").set(output_ticks); - algoRhythmExtractor->output("estimates").set(output_estimates); - algoRhythmExtractor->output("bpmIntervals").set(output_bpmIntervals); - algoRhythmExtractor->compute(); - val outputRhythmExtractor(val::object()); - outputRhythmExtractor.set("bpm", output_bpm); - outputRhythmExtractor.set("ticks", output_ticks); - outputRhythmExtractor.set("estimates", output_estimates); - outputRhythmExtractor.set("bpmIntervals", output_bpmIntervals); - delete algoRhythmExtractor; - return outputRhythmExtractor; -} - +RhythmExtractor::RhythmExtractor(const int frameHop, const int frameSize, const int hopSize, const float lastBeatInterval, const int maxTempo, const int minTempo, const int numberFrames, const float sampleRate, const std::vector& tempoHints, const float tolerance, const bool useBands, const bool useOnset) { + configure(frameHop, frameSize, hopSize, lastBeatInterval, maxTempo, minTempo, numberFrames, sampleRate, tempoHints, tolerance, useBands, useOnset); +} +RhythmExtractor::~RhythmExtractor() { + delete _rhythmextractor; +} +void RhythmExtractor::configure(const int frameHop, const int frameSize, const int hopSize, const float lastBeatInterval, const int maxTempo, const int minTempo, const int numberFrames, const float sampleRate, const std::vector& tempoHints, const float tolerance, const bool useBands, const bool useOnset) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _rhythmextractor = factory.create("RhythmExtractor", "frameHop", frameHop, "frameSize", frameSize, "hopSize", hopSize, "lastBeatInterval", lastBeatInterval, "maxTempo", maxTempo, "minTempo", minTempo, "numberFrames", numberFrames, "sampleRate", sampleRate, "tempoHints", tempoHints, "tolerance", tolerance, "useBands", useBands, "useOnset", useOnset); +} +val RhythmExtractor::compute(std::vector& input_signal) { + _rhythmextractor->input("signal").set(input_signal); + float output_bpm; + std::vector output_ticks; + std::vector output_estimates; + std::vector output_bpmIntervals; + _rhythmextractor->output("bpm").set(output_bpm); + _rhythmextractor->output("ticks").set(output_ticks); + _rhythmextractor->output("estimates").set(output_estimates); + _rhythmextractor->output("bpmIntervals").set(output_bpmIntervals); + _rhythmextractor->compute(); + val outputRhythmExtractor(val::object()); + outputRhythmExtractor.set("bpm", output_bpm); + outputRhythmExtractor.set("ticks", output_ticks); + outputRhythmExtractor.set("estimates", output_estimates); + outputRhythmExtractor.set("bpmIntervals", output_bpmIntervals); + return outputRhythmExtractor; +} +void RhythmExtractor::reset() { +_rhythmextractor->reset(); +} +// END RhythmExtractor definitions + +// START RhythmExtractor2013 definitions // check https://essentia.upf.edu/reference/std_RhythmExtractor2013.html -val EssentiaJS::RhythmExtractor2013(std::vector& input_signal, const int maxTempo, const std::string& method, const int minTempo) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoRhythmExtractor2013 = factory.create("RhythmExtractor2013", "maxTempo", maxTempo, "method", method, "minTempo", minTempo); - algoRhythmExtractor2013->input("signal").set(input_signal); - float output_bpm; - std::vector output_ticks; - float output_confidence; - std::vector output_estimates; - std::vector output_bpmIntervals; - algoRhythmExtractor2013->output("bpm").set(output_bpm); - algoRhythmExtractor2013->output("ticks").set(output_ticks); - algoRhythmExtractor2013->output("confidence").set(output_confidence); - algoRhythmExtractor2013->output("estimates").set(output_estimates); - algoRhythmExtractor2013->output("bpmIntervals").set(output_bpmIntervals); - algoRhythmExtractor2013->compute(); - val outputRhythmExtractor2013(val::object()); - outputRhythmExtractor2013.set("bpm", output_bpm); - outputRhythmExtractor2013.set("ticks", output_ticks); - outputRhythmExtractor2013.set("confidence", output_confidence); - outputRhythmExtractor2013.set("estimates", output_estimates); - outputRhythmExtractor2013.set("bpmIntervals", output_bpmIntervals); - delete algoRhythmExtractor2013; - return outputRhythmExtractor2013; -} - +RhythmExtractor2013::RhythmExtractor2013(const int maxTempo, const std::string& method, const int minTempo) { + configure(maxTempo, method, minTempo); +} +RhythmExtractor2013::~RhythmExtractor2013() { + delete _rhythmextractor2013; +} +void RhythmExtractor2013::configure(const int maxTempo, const std::string& method, const int minTempo) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _rhythmextractor2013 = factory.create("RhythmExtractor2013", "maxTempo", maxTempo, "method", method, "minTempo", minTempo); +} +val RhythmExtractor2013::compute(std::vector& input_signal) { + _rhythmextractor2013->input("signal").set(input_signal); + float output_bpm; + std::vector output_ticks; + float output_confidence; + std::vector output_estimates; + std::vector output_bpmIntervals; + _rhythmextractor2013->output("bpm").set(output_bpm); + _rhythmextractor2013->output("ticks").set(output_ticks); + _rhythmextractor2013->output("confidence").set(output_confidence); + _rhythmextractor2013->output("estimates").set(output_estimates); + _rhythmextractor2013->output("bpmIntervals").set(output_bpmIntervals); + _rhythmextractor2013->compute(); + val outputRhythmExtractor2013(val::object()); + outputRhythmExtractor2013.set("bpm", output_bpm); + outputRhythmExtractor2013.set("ticks", output_ticks); + outputRhythmExtractor2013.set("confidence", output_confidence); + outputRhythmExtractor2013.set("estimates", output_estimates); + outputRhythmExtractor2013.set("bpmIntervals", output_bpmIntervals); + return outputRhythmExtractor2013; +} +void RhythmExtractor2013::reset() { +_rhythmextractor2013->reset(); +} +// END RhythmExtractor2013 definitions + +// START RhythmTransform definitions // check https://essentia.upf.edu/reference/std_RhythmTransform.html -val EssentiaJS::RhythmTransform(std::vector >& input_melBands, const int frameSize, const int hopSize) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoRhythmTransform = factory.create("RhythmTransform", "frameSize", frameSize, "hopSize", hopSize); - algoRhythmTransform->input("melBands").set(input_melBands); - std::vector > output_rhythm; - algoRhythmTransform->output("rhythm").set(output_rhythm); - algoRhythmTransform->compute(); - val outputRhythmTransform(val::object()); - outputRhythmTransform.set("rhythm", output_rhythm); - delete algoRhythmTransform; - return outputRhythmTransform; -} - +RhythmTransform::RhythmTransform(const int frameSize, const int hopSize) { + configure(frameSize, hopSize); +} +RhythmTransform::~RhythmTransform() { + delete _rhythmtransform; +} +void RhythmTransform::configure(const int frameSize, const int hopSize) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _rhythmtransform = factory.create("RhythmTransform", "frameSize", frameSize, "hopSize", hopSize); +} +val RhythmTransform::compute(std::vector >& input_melBands) { + _rhythmtransform->input("melBands").set(input_melBands); + std::vector > output_rhythm; + _rhythmtransform->output("rhythm").set(output_rhythm); + _rhythmtransform->compute(); + val outputRhythmTransform(val::object()); + outputRhythmTransform.set("rhythm", output_rhythm); + return outputRhythmTransform; +} +void RhythmTransform::reset() { +_rhythmtransform->reset(); +} +// END RhythmTransform definitions + +// START RollOff definitions // check https://essentia.upf.edu/reference/std_RollOff.html -val EssentiaJS::RollOff(std::vector& input_spectrum, const float cutoff, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoRollOff = factory.create("RollOff", "cutoff", cutoff, "sampleRate", sampleRate); - algoRollOff->input("spectrum").set(input_spectrum); - float output_rollOff; - algoRollOff->output("rollOff").set(output_rollOff); - algoRollOff->compute(); - val outputRollOff(val::object()); - outputRollOff.set("rollOff", output_rollOff); - delete algoRollOff; - return outputRollOff; -} - +RollOff::RollOff(const float cutoff, const float sampleRate) { + configure(cutoff, sampleRate); +} +RollOff::~RollOff() { + delete _rolloff; +} +void RollOff::configure(const float cutoff, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _rolloff = factory.create("RollOff", "cutoff", cutoff, "sampleRate", sampleRate); +} +val RollOff::compute(std::vector& input_spectrum) { + _rolloff->input("spectrum").set(input_spectrum); + float output_rollOff; + _rolloff->output("rollOff").set(output_rollOff); + _rolloff->compute(); + val outputRollOff(val::object()); + outputRollOff.set("rollOff", output_rollOff); + return outputRollOff; +} +void RollOff::reset() { +_rolloff->reset(); +} +// END RollOff definitions + +// START SNR definitions // check https://essentia.upf.edu/reference/std_SNR.html -val EssentiaJS::SNR(std::vector& input_frame, const float MAAlpha, const float MMSEAlpha, const float NoiseAlpha, const int frameSize, const float noiseThreshold, const float sampleRate, const bool useBroadbadNoiseCorrection) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSNR = factory.create("SNR", "MAAlpha", MAAlpha, "MMSEAlpha", MMSEAlpha, "NoiseAlpha", NoiseAlpha, "frameSize", frameSize, "noiseThreshold", noiseThreshold, "sampleRate", sampleRate, "useBroadbadNoiseCorrection", useBroadbadNoiseCorrection); - algoSNR->input("frame").set(input_frame); - float output_instantSNR; - float output_averagedSNR; - std::vector output_spectralSNR; - algoSNR->output("instantSNR").set(output_instantSNR); - algoSNR->output("averagedSNR").set(output_averagedSNR); - algoSNR->output("spectralSNR").set(output_spectralSNR); - algoSNR->compute(); - val outputSNR(val::object()); - outputSNR.set("instantSNR", output_instantSNR); - outputSNR.set("averagedSNR", output_averagedSNR); - outputSNR.set("spectralSNR", output_spectralSNR); - delete algoSNR; - return outputSNR; -} - +SNR::SNR(const float MAAlpha, const float MMSEAlpha, const float NoiseAlpha, const int frameSize, const float noiseThreshold, const float sampleRate, const bool useBroadbadNoiseCorrection) { + configure(MAAlpha, MMSEAlpha, NoiseAlpha, frameSize, noiseThreshold, sampleRate, useBroadbadNoiseCorrection); +} +SNR::~SNR() { + delete _snr; +} +void SNR::configure(const float MAAlpha, const float MMSEAlpha, const float NoiseAlpha, const int frameSize, const float noiseThreshold, const float sampleRate, const bool useBroadbadNoiseCorrection) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _snr = factory.create("SNR", "MAAlpha", MAAlpha, "MMSEAlpha", MMSEAlpha, "NoiseAlpha", NoiseAlpha, "frameSize", frameSize, "noiseThreshold", noiseThreshold, "sampleRate", sampleRate, "useBroadbadNoiseCorrection", useBroadbadNoiseCorrection); +} +val SNR::compute(std::vector& input_frame) { + _snr->input("frame").set(input_frame); + float output_instantSNR; + float output_averagedSNR; + std::vector output_spectralSNR; + _snr->output("instantSNR").set(output_instantSNR); + _snr->output("averagedSNR").set(output_averagedSNR); + _snr->output("spectralSNR").set(output_spectralSNR); + _snr->compute(); + val outputSNR(val::object()); + outputSNR.set("instantSNR", output_instantSNR); + outputSNR.set("averagedSNR", output_averagedSNR); + outputSNR.set("spectralSNR", output_spectralSNR); + return outputSNR; +} +void SNR::reset() { +_snr->reset(); +} +// END SNR definitions + +// START SaturationDetector definitions // check https://essentia.upf.edu/reference/std_SaturationDetector.html -val EssentiaJS::SaturationDetector(std::vector& input_frame, const float differentialThreshold, const float energyThreshold, const int frameSize, const int hopSize, const float minimumDuration, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSaturationDetector = factory.create("SaturationDetector", "differentialThreshold", differentialThreshold, "energyThreshold", energyThreshold, "frameSize", frameSize, "hopSize", hopSize, "minimumDuration", minimumDuration, "sampleRate", sampleRate); - algoSaturationDetector->input("frame").set(input_frame); - std::vector output_starts; - std::vector output_ends; - algoSaturationDetector->output("starts").set(output_starts); - algoSaturationDetector->output("ends").set(output_ends); - algoSaturationDetector->compute(); - val outputSaturationDetector(val::object()); - outputSaturationDetector.set("starts", output_starts); - outputSaturationDetector.set("ends", output_ends); - delete algoSaturationDetector; - return outputSaturationDetector; -} - +SaturationDetector::SaturationDetector(const float differentialThreshold, const float energyThreshold, const int frameSize, const int hopSize, const float minimumDuration, const float sampleRate) { + configure(differentialThreshold, energyThreshold, frameSize, hopSize, minimumDuration, sampleRate); +} +SaturationDetector::~SaturationDetector() { + delete _saturationdetector; +} +void SaturationDetector::configure(const float differentialThreshold, const float energyThreshold, const int frameSize, const int hopSize, const float minimumDuration, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _saturationdetector = factory.create("SaturationDetector", "differentialThreshold", differentialThreshold, "energyThreshold", energyThreshold, "frameSize", frameSize, "hopSize", hopSize, "minimumDuration", minimumDuration, "sampleRate", sampleRate); +} +val SaturationDetector::compute(std::vector& input_frame) { + _saturationdetector->input("frame").set(input_frame); + std::vector output_starts; + std::vector output_ends; + _saturationdetector->output("starts").set(output_starts); + _saturationdetector->output("ends").set(output_ends); + _saturationdetector->compute(); + val outputSaturationDetector(val::object()); + outputSaturationDetector.set("starts", output_starts); + outputSaturationDetector.set("ends", output_ends); + return outputSaturationDetector; +} +void SaturationDetector::reset() { +_saturationdetector->reset(); +} +// END SaturationDetector definitions + +// START Scale definitions // check https://essentia.upf.edu/reference/std_Scale.html -val EssentiaJS::Scale(std::vector& input_signal, const bool clipping, const float factor, const float maxAbsValue) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoScale = factory.create("Scale", "clipping", clipping, "factor", factor, "maxAbsValue", maxAbsValue); - algoScale->input("signal").set(input_signal); - std::vector output_signal; - algoScale->output("signal").set(output_signal); - algoScale->compute(); - val outputScale(val::object()); - outputScale.set("signal", output_signal); - delete algoScale; - return outputScale; -} - +Scale::Scale(const bool clipping, const float factor, const float maxAbsValue) { + configure(clipping, factor, maxAbsValue); +} +Scale::~Scale() { + delete _scale; +} +void Scale::configure(const bool clipping, const float factor, const float maxAbsValue) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _scale = factory.create("Scale", "clipping", clipping, "factor", factor, "maxAbsValue", maxAbsValue); +} +val Scale::compute(std::vector& input_signal) { + _scale->input("signal").set(input_signal); + std::vector output_signal; + _scale->output("signal").set(output_signal); + _scale->compute(); + val outputScale(val::object()); + outputScale.set("signal", output_signal); + return outputScale; +} +void Scale::reset() { +_scale->reset(); +} +// END Scale definitions + +// START SineSubtraction definitions // check https://essentia.upf.edu/reference/std_SineSubtraction.html -val EssentiaJS::SineSubtraction(std::vector& input_frame, std::vector& input_magnitudes, std::vector& input_frequencies, std::vector& input_phases, const int fftSize, const int hopSize, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSineSubtraction = factory.create("SineSubtraction", "fftSize", fftSize, "hopSize", hopSize, "sampleRate", sampleRate); - algoSineSubtraction->input("frame").set(input_frame); - algoSineSubtraction->input("magnitudes").set(input_magnitudes); - algoSineSubtraction->input("frequencies").set(input_frequencies); - algoSineSubtraction->input("phases").set(input_phases); - std::vector output_frame; - algoSineSubtraction->output("frame").set(output_frame); - algoSineSubtraction->compute(); - val outputSineSubtraction(val::object()); - outputSineSubtraction.set("frame", output_frame); - delete algoSineSubtraction; - return outputSineSubtraction; -} - +SineSubtraction::SineSubtraction(const int fftSize, const int hopSize, const float sampleRate) { + configure(fftSize, hopSize, sampleRate); +} +SineSubtraction::~SineSubtraction() { + delete _sinesubtraction; +} +void SineSubtraction::configure(const int fftSize, const int hopSize, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _sinesubtraction = factory.create("SineSubtraction", "fftSize", fftSize, "hopSize", hopSize, "sampleRate", sampleRate); +} +val SineSubtraction::compute(std::vector& input_frame, std::vector& input_magnitudes, std::vector& input_frequencies, std::vector& input_phases) { + _sinesubtraction->input("frame").set(input_frame); + _sinesubtraction->input("magnitudes").set(input_magnitudes); + _sinesubtraction->input("frequencies").set(input_frequencies); + _sinesubtraction->input("phases").set(input_phases); + std::vector output_frame; + _sinesubtraction->output("frame").set(output_frame); + _sinesubtraction->compute(); + val outputSineSubtraction(val::object()); + outputSineSubtraction.set("frame", output_frame); + return outputSineSubtraction; +} +void SineSubtraction::reset() { +_sinesubtraction->reset(); +} +// END SineSubtraction definitions + +// START SingleBeatLoudness definitions // check https://essentia.upf.edu/reference/std_SingleBeatLoudness.html -val EssentiaJS::SingleBeatLoudness(std::vector& input_beat, const float beatDuration, const float beatWindowDuration, const std::vector& frequencyBands, const std::string& onsetStart, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSingleBeatLoudness = factory.create("SingleBeatLoudness", "beatDuration", beatDuration, "beatWindowDuration", beatWindowDuration, "frequencyBands", frequencyBands, "onsetStart", onsetStart, "sampleRate", sampleRate); - algoSingleBeatLoudness->input("beat").set(input_beat); - float output_loudness; - std::vector output_loudnessBandRatio; - algoSingleBeatLoudness->output("loudness").set(output_loudness); - algoSingleBeatLoudness->output("loudnessBandRatio").set(output_loudnessBandRatio); - algoSingleBeatLoudness->compute(); - val outputSingleBeatLoudness(val::object()); - outputSingleBeatLoudness.set("loudness", output_loudness); - outputSingleBeatLoudness.set("loudnessBandRatio", output_loudnessBandRatio); - delete algoSingleBeatLoudness; - return outputSingleBeatLoudness; -} - +SingleBeatLoudness::SingleBeatLoudness(const float beatDuration, const float beatWindowDuration, const std::vector& frequencyBands, const std::string& onsetStart, const float sampleRate) { + configure(beatDuration, beatWindowDuration, frequencyBands, onsetStart, sampleRate); +} +SingleBeatLoudness::~SingleBeatLoudness() { + delete _singlebeatloudness; +} +void SingleBeatLoudness::configure(const float beatDuration, const float beatWindowDuration, const std::vector& frequencyBands, const std::string& onsetStart, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _singlebeatloudness = factory.create("SingleBeatLoudness", "beatDuration", beatDuration, "beatWindowDuration", beatWindowDuration, "frequencyBands", frequencyBands, "onsetStart", onsetStart, "sampleRate", sampleRate); +} +val SingleBeatLoudness::compute(std::vector& input_beat) { + _singlebeatloudness->input("beat").set(input_beat); + float output_loudness; + std::vector output_loudnessBandRatio; + _singlebeatloudness->output("loudness").set(output_loudness); + _singlebeatloudness->output("loudnessBandRatio").set(output_loudnessBandRatio); + _singlebeatloudness->compute(); + val outputSingleBeatLoudness(val::object()); + outputSingleBeatLoudness.set("loudness", output_loudness); + outputSingleBeatLoudness.set("loudnessBandRatio", output_loudnessBandRatio); + return outputSingleBeatLoudness; +} +void SingleBeatLoudness::reset() { +_singlebeatloudness->reset(); +} +// END SingleBeatLoudness definitions + +// START Slicer definitions // check https://essentia.upf.edu/reference/std_Slicer.html -val EssentiaJS::Slicer(std::vector& input_audio, const std::vector& endTimes, const float sampleRate, const std::vector& startTimes, const std::string& timeUnits) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSlicer = factory.create("Slicer", "endTimes", endTimes, "sampleRate", sampleRate, "startTimes", startTimes, "timeUnits", timeUnits); - algoSlicer->input("audio").set(input_audio); - std::vector > output_frame; - algoSlicer->output("frame").set(output_frame); - algoSlicer->compute(); - val outputSlicer(val::object()); - outputSlicer.set("frame", output_frame); - delete algoSlicer; - return outputSlicer; -} - +Slicer::Slicer(const std::vector& endTimes, const float sampleRate, const std::vector& startTimes, const std::string& timeUnits) { + configure(endTimes, sampleRate, startTimes, timeUnits); +} +Slicer::~Slicer() { + delete _slicer; +} +void Slicer::configure(const std::vector& endTimes, const float sampleRate, const std::vector& startTimes, const std::string& timeUnits) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _slicer = factory.create("Slicer", "endTimes", endTimes, "sampleRate", sampleRate, "startTimes", startTimes, "timeUnits", timeUnits); +} +val Slicer::compute(std::vector& input_audio) { + _slicer->input("audio").set(input_audio); + std::vector > output_frame; + _slicer->output("frame").set(output_frame); + _slicer->compute(); + val outputSlicer(val::object()); + outputSlicer.set("frame", output_frame); + return outputSlicer; +} +void Slicer::reset() { +_slicer->reset(); +} +// END Slicer definitions + +// START SpectralCentroidTime definitions // check https://essentia.upf.edu/reference/std_SpectralCentroidTime.html -val EssentiaJS::SpectralCentroidTime(std::vector& input_array, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSpectralCentroidTime = factory.create("SpectralCentroidTime", "sampleRate", sampleRate); - algoSpectralCentroidTime->input("array").set(input_array); - float output_centroid; - algoSpectralCentroidTime->output("centroid").set(output_centroid); - algoSpectralCentroidTime->compute(); - val outputSpectralCentroidTime(val::object()); - outputSpectralCentroidTime.set("centroid", output_centroid); - delete algoSpectralCentroidTime; - return outputSpectralCentroidTime; -} - +SpectralCentroidTime::SpectralCentroidTime(const float sampleRate) { + configure(sampleRate); +} +SpectralCentroidTime::~SpectralCentroidTime() { + delete _spectralcentroidtime; +} +void SpectralCentroidTime::configure(const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _spectralcentroidtime = factory.create("SpectralCentroidTime", "sampleRate", sampleRate); +} +val SpectralCentroidTime::compute(std::vector& input_array) { + _spectralcentroidtime->input("array").set(input_array); + float output_centroid; + _spectralcentroidtime->output("centroid").set(output_centroid); + _spectralcentroidtime->compute(); + val outputSpectralCentroidTime(val::object()); + outputSpectralCentroidTime.set("centroid", output_centroid); + return outputSpectralCentroidTime; +} +void SpectralCentroidTime::reset() { +_spectralcentroidtime->reset(); +} +// END SpectralCentroidTime definitions + +// START SpectralComplexity definitions // check https://essentia.upf.edu/reference/std_SpectralComplexity.html -val EssentiaJS::SpectralComplexity(std::vector& input_spectrum, const float magnitudeThreshold, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSpectralComplexity = factory.create("SpectralComplexity", "magnitudeThreshold", magnitudeThreshold, "sampleRate", sampleRate); - algoSpectralComplexity->input("spectrum").set(input_spectrum); - float output_spectralComplexity; - algoSpectralComplexity->output("spectralComplexity").set(output_spectralComplexity); - algoSpectralComplexity->compute(); - val outputSpectralComplexity(val::object()); - outputSpectralComplexity.set("spectralComplexity", output_spectralComplexity); - delete algoSpectralComplexity; - return outputSpectralComplexity; -} - +SpectralComplexity::SpectralComplexity(const float magnitudeThreshold, const float sampleRate) { + configure(magnitudeThreshold, sampleRate); +} +SpectralComplexity::~SpectralComplexity() { + delete _spectralcomplexity; +} +void SpectralComplexity::configure(const float magnitudeThreshold, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _spectralcomplexity = factory.create("SpectralComplexity", "magnitudeThreshold", magnitudeThreshold, "sampleRate", sampleRate); +} +val SpectralComplexity::compute(std::vector& input_spectrum) { + _spectralcomplexity->input("spectrum").set(input_spectrum); + float output_spectralComplexity; + _spectralcomplexity->output("spectralComplexity").set(output_spectralComplexity); + _spectralcomplexity->compute(); + val outputSpectralComplexity(val::object()); + outputSpectralComplexity.set("spectralComplexity", output_spectralComplexity); + return outputSpectralComplexity; +} +void SpectralComplexity::reset() { +_spectralcomplexity->reset(); +} +// END SpectralComplexity definitions + +// START SpectralContrast definitions // check https://essentia.upf.edu/reference/std_SpectralContrast.html -val EssentiaJS::SpectralContrast(std::vector& input_spectrum, const int frameSize, const float highFrequencyBound, const float lowFrequencyBound, const float neighbourRatio, const int numberBands, const float sampleRate, const float staticDistribution) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSpectralContrast = factory.create("SpectralContrast", "frameSize", frameSize, "highFrequencyBound", highFrequencyBound, "lowFrequencyBound", lowFrequencyBound, "neighbourRatio", neighbourRatio, "numberBands", numberBands, "sampleRate", sampleRate, "staticDistribution", staticDistribution); - algoSpectralContrast->input("spectrum").set(input_spectrum); - std::vector output_spectralContrast; - std::vector output_spectralValley; - algoSpectralContrast->output("spectralContrast").set(output_spectralContrast); - algoSpectralContrast->output("spectralValley").set(output_spectralValley); - algoSpectralContrast->compute(); - val outputSpectralContrast(val::object()); - outputSpectralContrast.set("spectralContrast", output_spectralContrast); - outputSpectralContrast.set("spectralValley", output_spectralValley); - delete algoSpectralContrast; - return outputSpectralContrast; -} - +SpectralContrast::SpectralContrast(const int frameSize, const float highFrequencyBound, const float lowFrequencyBound, const float neighbourRatio, const int numberBands, const float sampleRate, const float staticDistribution) { + configure(frameSize, highFrequencyBound, lowFrequencyBound, neighbourRatio, numberBands, sampleRate, staticDistribution); +} +SpectralContrast::~SpectralContrast() { + delete _spectralcontrast; +} +void SpectralContrast::configure(const int frameSize, const float highFrequencyBound, const float lowFrequencyBound, const float neighbourRatio, const int numberBands, const float sampleRate, const float staticDistribution) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _spectralcontrast = factory.create("SpectralContrast", "frameSize", frameSize, "highFrequencyBound", highFrequencyBound, "lowFrequencyBound", lowFrequencyBound, "neighbourRatio", neighbourRatio, "numberBands", numberBands, "sampleRate", sampleRate, "staticDistribution", staticDistribution); +} +val SpectralContrast::compute(std::vector& input_spectrum) { + _spectralcontrast->input("spectrum").set(input_spectrum); + std::vector output_spectralContrast; + std::vector output_spectralValley; + _spectralcontrast->output("spectralContrast").set(output_spectralContrast); + _spectralcontrast->output("spectralValley").set(output_spectralValley); + _spectralcontrast->compute(); + val outputSpectralContrast(val::object()); + outputSpectralContrast.set("spectralContrast", output_spectralContrast); + outputSpectralContrast.set("spectralValley", output_spectralValley); + return outputSpectralContrast; +} +void SpectralContrast::reset() { +_spectralcontrast->reset(); +} +// END SpectralContrast definitions + +// START SpectralPeaks definitions // check https://essentia.upf.edu/reference/std_SpectralPeaks.html -val EssentiaJS::SpectralPeaks(std::vector& input_spectrum, const float magnitudeThreshold, const float maxFrequency, const int maxPeaks, const float minFrequency, const std::string& orderBy, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSpectralPeaks = factory.create("SpectralPeaks", "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "maxPeaks", maxPeaks, "minFrequency", minFrequency, "orderBy", orderBy, "sampleRate", sampleRate); - algoSpectralPeaks->input("spectrum").set(input_spectrum); - std::vector output_frequencies; - std::vector output_magnitudes; - algoSpectralPeaks->output("frequencies").set(output_frequencies); - algoSpectralPeaks->output("magnitudes").set(output_magnitudes); - algoSpectralPeaks->compute(); - val outputSpectralPeaks(val::object()); - outputSpectralPeaks.set("frequencies", output_frequencies); - outputSpectralPeaks.set("magnitudes", output_magnitudes); - delete algoSpectralPeaks; - return outputSpectralPeaks; -} - +SpectralPeaks::SpectralPeaks(const float magnitudeThreshold, const float maxFrequency, const int maxPeaks, const float minFrequency, const std::string& orderBy, const float sampleRate) { + configure(magnitudeThreshold, maxFrequency, maxPeaks, minFrequency, orderBy, sampleRate); +} +SpectralPeaks::~SpectralPeaks() { + delete _spectralpeaks; +} +void SpectralPeaks::configure(const float magnitudeThreshold, const float maxFrequency, const int maxPeaks, const float minFrequency, const std::string& orderBy, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _spectralpeaks = factory.create("SpectralPeaks", "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "maxPeaks", maxPeaks, "minFrequency", minFrequency, "orderBy", orderBy, "sampleRate", sampleRate); +} +val SpectralPeaks::compute(std::vector& input_spectrum) { + _spectralpeaks->input("spectrum").set(input_spectrum); + std::vector output_frequencies; + std::vector output_magnitudes; + _spectralpeaks->output("frequencies").set(output_frequencies); + _spectralpeaks->output("magnitudes").set(output_magnitudes); + _spectralpeaks->compute(); + val outputSpectralPeaks(val::object()); + outputSpectralPeaks.set("frequencies", output_frequencies); + outputSpectralPeaks.set("magnitudes", output_magnitudes); + return outputSpectralPeaks; +} +void SpectralPeaks::reset() { +_spectralpeaks->reset(); +} +// END SpectralPeaks definitions + +// START SpectralWhitening definitions // check https://essentia.upf.edu/reference/std_SpectralWhitening.html -val EssentiaJS::SpectralWhitening(std::vector& input_spectrum, std::vector& input_frequencies, std::vector& input_magnitudes, const float maxFrequency, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSpectralWhitening = factory.create("SpectralWhitening", "maxFrequency", maxFrequency, "sampleRate", sampleRate); - algoSpectralWhitening->input("spectrum").set(input_spectrum); - algoSpectralWhitening->input("frequencies").set(input_frequencies); - algoSpectralWhitening->input("magnitudes").set(input_magnitudes); - std::vector output_magnitudes; - algoSpectralWhitening->output("magnitudes").set(output_magnitudes); - algoSpectralWhitening->compute(); - val outputSpectralWhitening(val::object()); - outputSpectralWhitening.set("magnitudes", output_magnitudes); - delete algoSpectralWhitening; - return outputSpectralWhitening; -} - +SpectralWhitening::SpectralWhitening(const float maxFrequency, const float sampleRate) { + configure(maxFrequency, sampleRate); +} +SpectralWhitening::~SpectralWhitening() { + delete _spectralwhitening; +} +void SpectralWhitening::configure(const float maxFrequency, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _spectralwhitening = factory.create("SpectralWhitening", "maxFrequency", maxFrequency, "sampleRate", sampleRate); +} +val SpectralWhitening::compute(std::vector& input_spectrum, std::vector& input_frequencies, std::vector& input_magnitudes) { + _spectralwhitening->input("spectrum").set(input_spectrum); + _spectralwhitening->input("frequencies").set(input_frequencies); + _spectralwhitening->input("magnitudes").set(input_magnitudes); + std::vector output_magnitudes; + _spectralwhitening->output("magnitudes").set(output_magnitudes); + _spectralwhitening->compute(); + val outputSpectralWhitening(val::object()); + outputSpectralWhitening.set("magnitudes", output_magnitudes); + return outputSpectralWhitening; +} +void SpectralWhitening::reset() { +_spectralwhitening->reset(); +} +// END SpectralWhitening definitions + +// START Spectrum definitions // check https://essentia.upf.edu/reference/std_Spectrum.html -val EssentiaJS::Spectrum(std::vector& input_frame, const int size) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSpectrum = factory.create("Spectrum", "size", size); - algoSpectrum->input("frame").set(input_frame); - std::vector output_spectrum; - algoSpectrum->output("spectrum").set(output_spectrum); - algoSpectrum->compute(); - val outputSpectrum(val::object()); - outputSpectrum.set("spectrum", output_spectrum); - delete algoSpectrum; - return outputSpectrum; -} - +Spectrum::Spectrum(const int size) { + configure(size); +} +Spectrum::~Spectrum() { + delete _spectrum; +} +void Spectrum::configure(const int size) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _spectrum = factory.create("Spectrum", "size", size); +} +val Spectrum::compute(std::vector& input_frame) { + _spectrum->input("frame").set(input_frame); + std::vector output_spectrum; + _spectrum->output("spectrum").set(output_spectrum); + _spectrum->compute(); + val outputSpectrum(val::object()); + outputSpectrum.set("spectrum", output_spectrum); + return outputSpectrum; +} +void Spectrum::reset() { +_spectrum->reset(); +} +// END Spectrum definitions + +// START SpectrumCQ definitions // check https://essentia.upf.edu/reference/std_SpectrumCQ.html -val EssentiaJS::SpectrumCQ(std::vector& input_frame, const int binsPerOctave, const float minFrequency, const int minimumKernelSize, const int numberBins, const float sampleRate, const float scale, const float threshold, const std::string& windowType, const bool zeroPhase) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSpectrumCQ = factory.create("SpectrumCQ", "binsPerOctave", binsPerOctave, "minFrequency", minFrequency, "minimumKernelSize", minimumKernelSize, "numberBins", numberBins, "sampleRate", sampleRate, "scale", scale, "threshold", threshold, "windowType", windowType, "zeroPhase", zeroPhase); - algoSpectrumCQ->input("frame").set(input_frame); - std::vector output_spectrumCQ; - algoSpectrumCQ->output("spectrumCQ").set(output_spectrumCQ); - algoSpectrumCQ->compute(); - val outputSpectrumCQ(val::object()); - outputSpectrumCQ.set("spectrumCQ", output_spectrumCQ); - delete algoSpectrumCQ; - return outputSpectrumCQ; -} - +SpectrumCQ::SpectrumCQ(const int binsPerOctave, const float minFrequency, const int minimumKernelSize, const int numberBins, const float sampleRate, const float scale, const float threshold, const std::string& windowType, const bool zeroPhase) { + configure(binsPerOctave, minFrequency, minimumKernelSize, numberBins, sampleRate, scale, threshold, windowType, zeroPhase); +} +SpectrumCQ::~SpectrumCQ() { + delete _spectrumcq; +} +void SpectrumCQ::configure(const int binsPerOctave, const float minFrequency, const int minimumKernelSize, const int numberBins, const float sampleRate, const float scale, const float threshold, const std::string& windowType, const bool zeroPhase) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _spectrumcq = factory.create("SpectrumCQ", "binsPerOctave", binsPerOctave, "minFrequency", minFrequency, "minimumKernelSize", minimumKernelSize, "numberBins", numberBins, "sampleRate", sampleRate, "scale", scale, "threshold", threshold, "windowType", windowType, "zeroPhase", zeroPhase); +} +val SpectrumCQ::compute(std::vector& input_frame) { + _spectrumcq->input("frame").set(input_frame); + std::vector output_spectrumCQ; + _spectrumcq->output("spectrumCQ").set(output_spectrumCQ); + _spectrumcq->compute(); + val outputSpectrumCQ(val::object()); + outputSpectrumCQ.set("spectrumCQ", output_spectrumCQ); + return outputSpectrumCQ; +} +void SpectrumCQ::reset() { +_spectrumcq->reset(); +} +// END SpectrumCQ definitions + +// START SpectrumToCent definitions // check https://essentia.upf.edu/reference/std_SpectrumToCent.html -val EssentiaJS::SpectrumToCent(std::vector& input_spectrum, const int bands, const float centBinResolution, const int inputSize, const bool log, const float minimumFrequency, const std::string& normalize, const float sampleRate, const std::string& type) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSpectrumToCent = factory.create("SpectrumToCent", "bands", bands, "centBinResolution", centBinResolution, "inputSize", inputSize, "log", log, "minimumFrequency", minimumFrequency, "normalize", normalize, "sampleRate", sampleRate, "type", type); - algoSpectrumToCent->input("spectrum").set(input_spectrum); - std::vector output_bands; - std::vector output_frequencies; - algoSpectrumToCent->output("bands").set(output_bands); - algoSpectrumToCent->output("frequencies").set(output_frequencies); - algoSpectrumToCent->compute(); - val outputSpectrumToCent(val::object()); - outputSpectrumToCent.set("bands", output_bands); - outputSpectrumToCent.set("frequencies", output_frequencies); - delete algoSpectrumToCent; - return outputSpectrumToCent; -} - +SpectrumToCent::SpectrumToCent(const int bands, const float centBinResolution, const int inputSize, const bool log, const float minimumFrequency, const std::string& normalize, const float sampleRate, const std::string& type) { + configure(bands, centBinResolution, inputSize, log, minimumFrequency, normalize, sampleRate, type); +} +SpectrumToCent::~SpectrumToCent() { + delete _spectrumtocent; +} +void SpectrumToCent::configure(const int bands, const float centBinResolution, const int inputSize, const bool log, const float minimumFrequency, const std::string& normalize, const float sampleRate, const std::string& type) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _spectrumtocent = factory.create("SpectrumToCent", "bands", bands, "centBinResolution", centBinResolution, "inputSize", inputSize, "log", log, "minimumFrequency", minimumFrequency, "normalize", normalize, "sampleRate", sampleRate, "type", type); +} +val SpectrumToCent::compute(std::vector& input_spectrum) { + _spectrumtocent->input("spectrum").set(input_spectrum); + std::vector output_bands; + std::vector output_frequencies; + _spectrumtocent->output("bands").set(output_bands); + _spectrumtocent->output("frequencies").set(output_frequencies); + _spectrumtocent->compute(); + val outputSpectrumToCent(val::object()); + outputSpectrumToCent.set("bands", output_bands); + outputSpectrumToCent.set("frequencies", output_frequencies); + return outputSpectrumToCent; +} +void SpectrumToCent::reset() { +_spectrumtocent->reset(); +} +// END SpectrumToCent definitions + +// START Spline definitions // check https://essentia.upf.edu/reference/std_Spline.html -val EssentiaJS::Spline(float input_x, const float beta1, const float beta2, const std::string& type, const std::vector& xPoints, const std::vector& yPoints) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSpline = factory.create("Spline", "beta1", beta1, "beta2", beta2, "type", type, "xPoints", xPoints, "yPoints", yPoints); - algoSpline->input("x").set(input_x); - float output_y; - algoSpline->output("y").set(output_y); - algoSpline->compute(); - val outputSpline(val::object()); - outputSpline.set("y", output_y); - delete algoSpline; - return outputSpline; -} - +Spline::Spline(const float beta1, const float beta2, const std::string& type, const std::vector& xPoints, const std::vector& yPoints) { + configure(beta1, beta2, type, xPoints, yPoints); +} +Spline::~Spline() { + delete _spline; +} +void Spline::configure(const float beta1, const float beta2, const std::string& type, const std::vector& xPoints, const std::vector& yPoints) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _spline = factory.create("Spline", "beta1", beta1, "beta2", beta2, "type", type, "xPoints", xPoints, "yPoints", yPoints); +} +val Spline::compute(float input_x) { + _spline->input("x").set(input_x); + float output_y; + _spline->output("y").set(output_y); + _spline->compute(); + val outputSpline(val::object()); + outputSpline.set("y", output_y); + return outputSpline; +} +void Spline::reset() { +_spline->reset(); +} +// END Spline definitions + +// START SprModelAnal definitions // check https://essentia.upf.edu/reference/std_SprModelAnal.html -val EssentiaJS::SprModelAnal(std::vector& input_frame, const int fftSize, const int freqDevOffset, const float freqDevSlope, const int hopSize, const float magnitudeThreshold, const float maxFrequency, const int maxPeaks, const int maxnSines, const float minFrequency, const std::string& orderBy, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSprModelAnal = factory.create("SprModelAnal", "fftSize", fftSize, "freqDevOffset", freqDevOffset, "freqDevSlope", freqDevSlope, "hopSize", hopSize, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "maxPeaks", maxPeaks, "maxnSines", maxnSines, "minFrequency", minFrequency, "orderBy", orderBy, "sampleRate", sampleRate); - algoSprModelAnal->input("frame").set(input_frame); - std::vector output_frequencies; - std::vector output_magnitudes; - std::vector output_phases; - std::vector output_res; - algoSprModelAnal->output("frequencies").set(output_frequencies); - algoSprModelAnal->output("magnitudes").set(output_magnitudes); - algoSprModelAnal->output("phases").set(output_phases); - algoSprModelAnal->output("res").set(output_res); - algoSprModelAnal->compute(); - val outputSprModelAnal(val::object()); - outputSprModelAnal.set("frequencies", output_frequencies); - outputSprModelAnal.set("magnitudes", output_magnitudes); - outputSprModelAnal.set("phases", output_phases); - outputSprModelAnal.set("res", output_res); - delete algoSprModelAnal; - return outputSprModelAnal; -} - +SprModelAnal::SprModelAnal(const int fftSize, const int freqDevOffset, const float freqDevSlope, const int hopSize, const float magnitudeThreshold, const float maxFrequency, const int maxPeaks, const int maxnSines, const float minFrequency, const std::string& orderBy, const float sampleRate) { + configure(fftSize, freqDevOffset, freqDevSlope, hopSize, magnitudeThreshold, maxFrequency, maxPeaks, maxnSines, minFrequency, orderBy, sampleRate); +} +SprModelAnal::~SprModelAnal() { + delete _sprmodelanal; +} +void SprModelAnal::configure(const int fftSize, const int freqDevOffset, const float freqDevSlope, const int hopSize, const float magnitudeThreshold, const float maxFrequency, const int maxPeaks, const int maxnSines, const float minFrequency, const std::string& orderBy, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _sprmodelanal = factory.create("SprModelAnal", "fftSize", fftSize, "freqDevOffset", freqDevOffset, "freqDevSlope", freqDevSlope, "hopSize", hopSize, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "maxPeaks", maxPeaks, "maxnSines", maxnSines, "minFrequency", minFrequency, "orderBy", orderBy, "sampleRate", sampleRate); +} +val SprModelAnal::compute(std::vector& input_frame) { + _sprmodelanal->input("frame").set(input_frame); + std::vector output_frequencies; + std::vector output_magnitudes; + std::vector output_phases; + std::vector output_res; + _sprmodelanal->output("frequencies").set(output_frequencies); + _sprmodelanal->output("magnitudes").set(output_magnitudes); + _sprmodelanal->output("phases").set(output_phases); + _sprmodelanal->output("res").set(output_res); + _sprmodelanal->compute(); + val outputSprModelAnal(val::object()); + outputSprModelAnal.set("frequencies", output_frequencies); + outputSprModelAnal.set("magnitudes", output_magnitudes); + outputSprModelAnal.set("phases", output_phases); + outputSprModelAnal.set("res", output_res); + return outputSprModelAnal; +} +void SprModelAnal::reset() { +_sprmodelanal->reset(); +} +// END SprModelAnal definitions + +// START SprModelSynth definitions // check https://essentia.upf.edu/reference/std_SprModelSynth.html -val EssentiaJS::SprModelSynth(std::vector& input_magnitudes, std::vector& input_frequencies, std::vector& input_phases, std::vector& input_res, const int fftSize, const int hopSize, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSprModelSynth = factory.create("SprModelSynth", "fftSize", fftSize, "hopSize", hopSize, "sampleRate", sampleRate); - algoSprModelSynth->input("magnitudes").set(input_magnitudes); - algoSprModelSynth->input("frequencies").set(input_frequencies); - algoSprModelSynth->input("phases").set(input_phases); - algoSprModelSynth->input("res").set(input_res); - std::vector output_frame; - std::vector output_sineframe; - std::vector output_resframe; - algoSprModelSynth->output("frame").set(output_frame); - algoSprModelSynth->output("sineframe").set(output_sineframe); - algoSprModelSynth->output("resframe").set(output_resframe); - algoSprModelSynth->compute(); - val outputSprModelSynth(val::object()); - outputSprModelSynth.set("frame", output_frame); - outputSprModelSynth.set("sineframe", output_sineframe); - outputSprModelSynth.set("resframe", output_resframe); - delete algoSprModelSynth; - return outputSprModelSynth; -} - +SprModelSynth::SprModelSynth(const int fftSize, const int hopSize, const float sampleRate) { + configure(fftSize, hopSize, sampleRate); +} +SprModelSynth::~SprModelSynth() { + delete _sprmodelsynth; +} +void SprModelSynth::configure(const int fftSize, const int hopSize, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _sprmodelsynth = factory.create("SprModelSynth", "fftSize", fftSize, "hopSize", hopSize, "sampleRate", sampleRate); +} +val SprModelSynth::compute(std::vector& input_magnitudes, std::vector& input_frequencies, std::vector& input_phases, std::vector& input_res) { + _sprmodelsynth->input("magnitudes").set(input_magnitudes); + _sprmodelsynth->input("frequencies").set(input_frequencies); + _sprmodelsynth->input("phases").set(input_phases); + _sprmodelsynth->input("res").set(input_res); + std::vector output_frame; + std::vector output_sineframe; + std::vector output_resframe; + _sprmodelsynth->output("frame").set(output_frame); + _sprmodelsynth->output("sineframe").set(output_sineframe); + _sprmodelsynth->output("resframe").set(output_resframe); + _sprmodelsynth->compute(); + val outputSprModelSynth(val::object()); + outputSprModelSynth.set("frame", output_frame); + outputSprModelSynth.set("sineframe", output_sineframe); + outputSprModelSynth.set("resframe", output_resframe); + return outputSprModelSynth; +} +void SprModelSynth::reset() { +_sprmodelsynth->reset(); +} +// END SprModelSynth definitions + +// START SpsModelAnal definitions // check https://essentia.upf.edu/reference/std_SpsModelAnal.html -val EssentiaJS::SpsModelAnal(std::vector& input_frame, const int fftSize, const int freqDevOffset, const float freqDevSlope, const int hopSize, const float magnitudeThreshold, const float maxFrequency, const int maxPeaks, const int maxnSines, const float minFrequency, const std::string& orderBy, const float sampleRate, const float stocf) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSpsModelAnal = factory.create("SpsModelAnal", "fftSize", fftSize, "freqDevOffset", freqDevOffset, "freqDevSlope", freqDevSlope, "hopSize", hopSize, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "maxPeaks", maxPeaks, "maxnSines", maxnSines, "minFrequency", minFrequency, "orderBy", orderBy, "sampleRate", sampleRate, "stocf", stocf); - algoSpsModelAnal->input("frame").set(input_frame); - std::vector output_frequencies; - std::vector output_magnitudes; - std::vector output_phases; - std::vector output_stocenv; - algoSpsModelAnal->output("frequencies").set(output_frequencies); - algoSpsModelAnal->output("magnitudes").set(output_magnitudes); - algoSpsModelAnal->output("phases").set(output_phases); - algoSpsModelAnal->output("stocenv").set(output_stocenv); - algoSpsModelAnal->compute(); - val outputSpsModelAnal(val::object()); - outputSpsModelAnal.set("frequencies", output_frequencies); - outputSpsModelAnal.set("magnitudes", output_magnitudes); - outputSpsModelAnal.set("phases", output_phases); - outputSpsModelAnal.set("stocenv", output_stocenv); - delete algoSpsModelAnal; - return outputSpsModelAnal; -} - +SpsModelAnal::SpsModelAnal(const int fftSize, const int freqDevOffset, const float freqDevSlope, const int hopSize, const float magnitudeThreshold, const float maxFrequency, const int maxPeaks, const int maxnSines, const float minFrequency, const std::string& orderBy, const float sampleRate, const float stocf) { + configure(fftSize, freqDevOffset, freqDevSlope, hopSize, magnitudeThreshold, maxFrequency, maxPeaks, maxnSines, minFrequency, orderBy, sampleRate, stocf); +} +SpsModelAnal::~SpsModelAnal() { + delete _spsmodelanal; +} +void SpsModelAnal::configure(const int fftSize, const int freqDevOffset, const float freqDevSlope, const int hopSize, const float magnitudeThreshold, const float maxFrequency, const int maxPeaks, const int maxnSines, const float minFrequency, const std::string& orderBy, const float sampleRate, const float stocf) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _spsmodelanal = factory.create("SpsModelAnal", "fftSize", fftSize, "freqDevOffset", freqDevOffset, "freqDevSlope", freqDevSlope, "hopSize", hopSize, "magnitudeThreshold", magnitudeThreshold, "maxFrequency", maxFrequency, "maxPeaks", maxPeaks, "maxnSines", maxnSines, "minFrequency", minFrequency, "orderBy", orderBy, "sampleRate", sampleRate, "stocf", stocf); +} +val SpsModelAnal::compute(std::vector& input_frame) { + _spsmodelanal->input("frame").set(input_frame); + std::vector output_frequencies; + std::vector output_magnitudes; + std::vector output_phases; + std::vector output_stocenv; + _spsmodelanal->output("frequencies").set(output_frequencies); + _spsmodelanal->output("magnitudes").set(output_magnitudes); + _spsmodelanal->output("phases").set(output_phases); + _spsmodelanal->output("stocenv").set(output_stocenv); + _spsmodelanal->compute(); + val outputSpsModelAnal(val::object()); + outputSpsModelAnal.set("frequencies", output_frequencies); + outputSpsModelAnal.set("magnitudes", output_magnitudes); + outputSpsModelAnal.set("phases", output_phases); + outputSpsModelAnal.set("stocenv", output_stocenv); + return outputSpsModelAnal; +} +void SpsModelAnal::reset() { +_spsmodelanal->reset(); +} +// END SpsModelAnal definitions + +// START SpsModelSynth definitions // check https://essentia.upf.edu/reference/std_SpsModelSynth.html -val EssentiaJS::SpsModelSynth(std::vector& input_magnitudes, std::vector& input_frequencies, std::vector& input_phases, std::vector& input_stocenv, const int fftSize, const int hopSize, const float sampleRate, const float stocf) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSpsModelSynth = factory.create("SpsModelSynth", "fftSize", fftSize, "hopSize", hopSize, "sampleRate", sampleRate, "stocf", stocf); - algoSpsModelSynth->input("magnitudes").set(input_magnitudes); - algoSpsModelSynth->input("frequencies").set(input_frequencies); - algoSpsModelSynth->input("phases").set(input_phases); - algoSpsModelSynth->input("stocenv").set(input_stocenv); - std::vector output_frame; - std::vector output_sineframe; - std::vector output_stocframe; - algoSpsModelSynth->output("frame").set(output_frame); - algoSpsModelSynth->output("sineframe").set(output_sineframe); - algoSpsModelSynth->output("stocframe").set(output_stocframe); - algoSpsModelSynth->compute(); - val outputSpsModelSynth(val::object()); - outputSpsModelSynth.set("frame", output_frame); - outputSpsModelSynth.set("sineframe", output_sineframe); - outputSpsModelSynth.set("stocframe", output_stocframe); - delete algoSpsModelSynth; - return outputSpsModelSynth; -} - +SpsModelSynth::SpsModelSynth(const int fftSize, const int hopSize, const float sampleRate, const float stocf) { + configure(fftSize, hopSize, sampleRate, stocf); +} +SpsModelSynth::~SpsModelSynth() { + delete _spsmodelsynth; +} +void SpsModelSynth::configure(const int fftSize, const int hopSize, const float sampleRate, const float stocf) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _spsmodelsynth = factory.create("SpsModelSynth", "fftSize", fftSize, "hopSize", hopSize, "sampleRate", sampleRate, "stocf", stocf); +} +val SpsModelSynth::compute(std::vector& input_magnitudes, std::vector& input_frequencies, std::vector& input_phases, std::vector& input_stocenv) { + _spsmodelsynth->input("magnitudes").set(input_magnitudes); + _spsmodelsynth->input("frequencies").set(input_frequencies); + _spsmodelsynth->input("phases").set(input_phases); + _spsmodelsynth->input("stocenv").set(input_stocenv); + std::vector output_frame; + std::vector output_sineframe; + std::vector output_stocframe; + _spsmodelsynth->output("frame").set(output_frame); + _spsmodelsynth->output("sineframe").set(output_sineframe); + _spsmodelsynth->output("stocframe").set(output_stocframe); + _spsmodelsynth->compute(); + val outputSpsModelSynth(val::object()); + outputSpsModelSynth.set("frame", output_frame); + outputSpsModelSynth.set("sineframe", output_sineframe); + outputSpsModelSynth.set("stocframe", output_stocframe); + return outputSpsModelSynth; +} +void SpsModelSynth::reset() { +_spsmodelsynth->reset(); +} +// END SpsModelSynth definitions + +// START StartStopCut definitions // check https://essentia.upf.edu/reference/std_StartStopCut.html -val EssentiaJS::StartStopCut(std::vector& input_audio, const int frameSize, const int hopSize, const float maximumStartTime, const float maximumStopTime, const float sampleRate, const int threshold) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoStartStopCut = factory.create("StartStopCut", "frameSize", frameSize, "hopSize", hopSize, "maximumStartTime", maximumStartTime, "maximumStopTime", maximumStopTime, "sampleRate", sampleRate, "threshold", threshold); - algoStartStopCut->input("audio").set(input_audio); - int output_startCut; - int output_stopCut; - algoStartStopCut->output("startCut").set(output_startCut); - algoStartStopCut->output("stopCut").set(output_stopCut); - algoStartStopCut->compute(); - val outputStartStopCut(val::object()); - outputStartStopCut.set("startCut", output_startCut); - outputStartStopCut.set("stopCut", output_stopCut); - delete algoStartStopCut; - return outputStartStopCut; -} - +StartStopCut::StartStopCut(const int frameSize, const int hopSize, const float maximumStartTime, const float maximumStopTime, const float sampleRate, const int threshold) { + configure(frameSize, hopSize, maximumStartTime, maximumStopTime, sampleRate, threshold); +} +StartStopCut::~StartStopCut() { + delete _startstopcut; +} +void StartStopCut::configure(const int frameSize, const int hopSize, const float maximumStartTime, const float maximumStopTime, const float sampleRate, const int threshold) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _startstopcut = factory.create("StartStopCut", "frameSize", frameSize, "hopSize", hopSize, "maximumStartTime", maximumStartTime, "maximumStopTime", maximumStopTime, "sampleRate", sampleRate, "threshold", threshold); +} +val StartStopCut::compute(std::vector& input_audio) { + _startstopcut->input("audio").set(input_audio); + int output_startCut; + int output_stopCut; + _startstopcut->output("startCut").set(output_startCut); + _startstopcut->output("stopCut").set(output_stopCut); + _startstopcut->compute(); + val outputStartStopCut(val::object()); + outputStartStopCut.set("startCut", output_startCut); + outputStartStopCut.set("stopCut", output_stopCut); + return outputStartStopCut; +} +void StartStopCut::reset() { +_startstopcut->reset(); +} +// END StartStopCut definitions + +// START StartStopSilence definitions // check https://essentia.upf.edu/reference/std_StartStopSilence.html -val EssentiaJS::StartStopSilence(std::vector& input_frame, const int threshold) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoStartStopSilence = factory.create("StartStopSilence", "threshold", threshold); - algoStartStopSilence->input("frame").set(input_frame); - int output_startFrame; - int output_stopFrame; - algoStartStopSilence->output("startFrame").set(output_startFrame); - algoStartStopSilence->output("stopFrame").set(output_stopFrame); - algoStartStopSilence->compute(); - val outputStartStopSilence(val::object()); - outputStartStopSilence.set("startFrame", output_startFrame); - outputStartStopSilence.set("stopFrame", output_stopFrame); - delete algoStartStopSilence; - return outputStartStopSilence; -} - +StartStopSilence::StartStopSilence(const int threshold) { + configure(threshold); +} +StartStopSilence::~StartStopSilence() { + delete _startstopsilence; +} +void StartStopSilence::configure(const int threshold) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _startstopsilence = factory.create("StartStopSilence", "threshold", threshold); +} +val StartStopSilence::compute(std::vector& input_frame) { + _startstopsilence->input("frame").set(input_frame); + int output_startFrame; + int output_stopFrame; + _startstopsilence->output("startFrame").set(output_startFrame); + _startstopsilence->output("stopFrame").set(output_stopFrame); + _startstopsilence->compute(); + val outputStartStopSilence(val::object()); + outputStartStopSilence.set("startFrame", output_startFrame); + outputStartStopSilence.set("stopFrame", output_stopFrame); + return outputStartStopSilence; +} +void StartStopSilence::reset() { +_startstopsilence->reset(); +} +// END StartStopSilence definitions + +// START StochasticModelAnal definitions // check https://essentia.upf.edu/reference/std_StochasticModelAnal.html -val EssentiaJS::StochasticModelAnal(std::vector& input_frame, const int fftSize, const int hopSize, const float sampleRate, const float stocf) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoStochasticModelAnal = factory.create("StochasticModelAnal", "fftSize", fftSize, "hopSize", hopSize, "sampleRate", sampleRate, "stocf", stocf); - algoStochasticModelAnal->input("frame").set(input_frame); - std::vector output_stocenv; - algoStochasticModelAnal->output("stocenv").set(output_stocenv); - algoStochasticModelAnal->compute(); - val outputStochasticModelAnal(val::object()); - outputStochasticModelAnal.set("stocenv", output_stocenv); - delete algoStochasticModelAnal; - return outputStochasticModelAnal; -} - +StochasticModelAnal::StochasticModelAnal(const int fftSize, const int hopSize, const float sampleRate, const float stocf) { + configure(fftSize, hopSize, sampleRate, stocf); +} +StochasticModelAnal::~StochasticModelAnal() { + delete _stochasticmodelanal; +} +void StochasticModelAnal::configure(const int fftSize, const int hopSize, const float sampleRate, const float stocf) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _stochasticmodelanal = factory.create("StochasticModelAnal", "fftSize", fftSize, "hopSize", hopSize, "sampleRate", sampleRate, "stocf", stocf); +} +val StochasticModelAnal::compute(std::vector& input_frame) { + _stochasticmodelanal->input("frame").set(input_frame); + std::vector output_stocenv; + _stochasticmodelanal->output("stocenv").set(output_stocenv); + _stochasticmodelanal->compute(); + val outputStochasticModelAnal(val::object()); + outputStochasticModelAnal.set("stocenv", output_stocenv); + return outputStochasticModelAnal; +} +void StochasticModelAnal::reset() { +_stochasticmodelanal->reset(); +} +// END StochasticModelAnal definitions + +// START StochasticModelSynth definitions // check https://essentia.upf.edu/reference/std_StochasticModelSynth.html -val EssentiaJS::StochasticModelSynth(std::vector& input_stocenv, const int fftSize, const int hopSize, const float sampleRate, const float stocf) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoStochasticModelSynth = factory.create("StochasticModelSynth", "fftSize", fftSize, "hopSize", hopSize, "sampleRate", sampleRate, "stocf", stocf); - algoStochasticModelSynth->input("stocenv").set(input_stocenv); - std::vector output_frame; - algoStochasticModelSynth->output("frame").set(output_frame); - algoStochasticModelSynth->compute(); - val outputStochasticModelSynth(val::object()); - outputStochasticModelSynth.set("frame", output_frame); - delete algoStochasticModelSynth; - return outputStochasticModelSynth; -} - +StochasticModelSynth::StochasticModelSynth(const int fftSize, const int hopSize, const float sampleRate, const float stocf) { + configure(fftSize, hopSize, sampleRate, stocf); +} +StochasticModelSynth::~StochasticModelSynth() { + delete _stochasticmodelsynth; +} +void StochasticModelSynth::configure(const int fftSize, const int hopSize, const float sampleRate, const float stocf) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _stochasticmodelsynth = factory.create("StochasticModelSynth", "fftSize", fftSize, "hopSize", hopSize, "sampleRate", sampleRate, "stocf", stocf); +} +val StochasticModelSynth::compute(std::vector& input_stocenv) { + _stochasticmodelsynth->input("stocenv").set(input_stocenv); + std::vector output_frame; + _stochasticmodelsynth->output("frame").set(output_frame); + _stochasticmodelsynth->compute(); + val outputStochasticModelSynth(val::object()); + outputStochasticModelSynth.set("frame", output_frame); + return outputStochasticModelSynth; +} +void StochasticModelSynth::reset() { +_stochasticmodelsynth->reset(); +} +// END StochasticModelSynth definitions + +// START StrongDecay definitions // check https://essentia.upf.edu/reference/std_StrongDecay.html -val EssentiaJS::StrongDecay(std::vector& input_signal, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoStrongDecay = factory.create("StrongDecay", "sampleRate", sampleRate); - algoStrongDecay->input("signal").set(input_signal); - float output_strongDecay; - algoStrongDecay->output("strongDecay").set(output_strongDecay); - algoStrongDecay->compute(); - val outputStrongDecay(val::object()); - outputStrongDecay.set("strongDecay", output_strongDecay); - delete algoStrongDecay; - return outputStrongDecay; -} - +StrongDecay::StrongDecay(const float sampleRate) { + configure(sampleRate); +} +StrongDecay::~StrongDecay() { + delete _strongdecay; +} +void StrongDecay::configure(const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _strongdecay = factory.create("StrongDecay", "sampleRate", sampleRate); +} +val StrongDecay::compute(std::vector& input_signal) { + _strongdecay->input("signal").set(input_signal); + float output_strongDecay; + _strongdecay->output("strongDecay").set(output_strongDecay); + _strongdecay->compute(); + val outputStrongDecay(val::object()); + outputStrongDecay.set("strongDecay", output_strongDecay); + return outputStrongDecay; +} +void StrongDecay::reset() { +_strongdecay->reset(); +} +// END StrongDecay definitions + +// START StrongPeak definitions // check https://essentia.upf.edu/reference/std_StrongPeak.html -val EssentiaJS::StrongPeak(std::vector& input_spectrum) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoStrongPeak = factory.create("StrongPeak"); - algoStrongPeak->input("spectrum").set(input_spectrum); - float output_strongPeak; - algoStrongPeak->output("strongPeak").set(output_strongPeak); - algoStrongPeak->compute(); - val outputStrongPeak(val::object()); - outputStrongPeak.set("strongPeak", output_strongPeak); - delete algoStrongPeak; - return outputStrongPeak; -} - +StrongPeak::StrongPeak() { + configure(); +} +StrongPeak::~StrongPeak() { + delete _strongpeak; +} +void StrongPeak::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _strongpeak = factory.create("StrongPeak"); +} +val StrongPeak::compute(std::vector& input_spectrum) { + _strongpeak->input("spectrum").set(input_spectrum); + float output_strongPeak; + _strongpeak->output("strongPeak").set(output_strongPeak); + _strongpeak->compute(); + val outputStrongPeak(val::object()); + outputStrongPeak.set("strongPeak", output_strongPeak); + return outputStrongPeak; +} +void StrongPeak::reset() { +_strongpeak->reset(); +} +// END StrongPeak definitions + +// START SuperFluxExtractor definitions // check https://essentia.upf.edu/reference/std_SuperFluxExtractor.html -val EssentiaJS::SuperFluxExtractor(std::vector& input_signal, const float combine, const int frameSize, const int hopSize, const float ratioThreshold, const float sampleRate, const float threshold) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSuperFluxExtractor = factory.create("SuperFluxExtractor", "combine", combine, "frameSize", frameSize, "hopSize", hopSize, "ratioThreshold", ratioThreshold, "sampleRate", sampleRate, "threshold", threshold); - algoSuperFluxExtractor->input("signal").set(input_signal); - std::vector output_onsets; - algoSuperFluxExtractor->output("onsets").set(output_onsets); - algoSuperFluxExtractor->compute(); - val outputSuperFluxExtractor(val::object()); - outputSuperFluxExtractor.set("onsets", output_onsets); - delete algoSuperFluxExtractor; - return outputSuperFluxExtractor; -} - +SuperFluxExtractor::SuperFluxExtractor(const float combine, const int frameSize, const int hopSize, const float ratioThreshold, const float sampleRate, const float threshold) { + configure(combine, frameSize, hopSize, ratioThreshold, sampleRate, threshold); +} +SuperFluxExtractor::~SuperFluxExtractor() { + delete _superfluxextractor; +} +void SuperFluxExtractor::configure(const float combine, const int frameSize, const int hopSize, const float ratioThreshold, const float sampleRate, const float threshold) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _superfluxextractor = factory.create("SuperFluxExtractor", "combine", combine, "frameSize", frameSize, "hopSize", hopSize, "ratioThreshold", ratioThreshold, "sampleRate", sampleRate, "threshold", threshold); +} +val SuperFluxExtractor::compute(std::vector& input_signal) { + _superfluxextractor->input("signal").set(input_signal); + std::vector output_onsets; + _superfluxextractor->output("onsets").set(output_onsets); + _superfluxextractor->compute(); + val outputSuperFluxExtractor(val::object()); + outputSuperFluxExtractor.set("onsets", output_onsets); + return outputSuperFluxExtractor; +} +void SuperFluxExtractor::reset() { +_superfluxextractor->reset(); +} +// END SuperFluxExtractor definitions + +// START SuperFluxNovelty definitions // check https://essentia.upf.edu/reference/std_SuperFluxNovelty.html -val EssentiaJS::SuperFluxNovelty(std::vector >& input_bands, const int binWidth, const int frameWidth) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSuperFluxNovelty = factory.create("SuperFluxNovelty", "binWidth", binWidth, "frameWidth", frameWidth); - algoSuperFluxNovelty->input("bands").set(input_bands); - float output_differences; - algoSuperFluxNovelty->output("differences").set(output_differences); - algoSuperFluxNovelty->compute(); - val outputSuperFluxNovelty(val::object()); - outputSuperFluxNovelty.set("differences", output_differences); - delete algoSuperFluxNovelty; - return outputSuperFluxNovelty; -} - +SuperFluxNovelty::SuperFluxNovelty(const int binWidth, const int frameWidth) { + configure(binWidth, frameWidth); +} +SuperFluxNovelty::~SuperFluxNovelty() { + delete _superfluxnovelty; +} +void SuperFluxNovelty::configure(const int binWidth, const int frameWidth) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _superfluxnovelty = factory.create("SuperFluxNovelty", "binWidth", binWidth, "frameWidth", frameWidth); +} +val SuperFluxNovelty::compute(std::vector >& input_bands) { + _superfluxnovelty->input("bands").set(input_bands); + float output_differences; + _superfluxnovelty->output("differences").set(output_differences); + _superfluxnovelty->compute(); + val outputSuperFluxNovelty(val::object()); + outputSuperFluxNovelty.set("differences", output_differences); + return outputSuperFluxNovelty; +} +void SuperFluxNovelty::reset() { +_superfluxnovelty->reset(); +} +// END SuperFluxNovelty definitions + +// START SuperFluxPeaks definitions // check https://essentia.upf.edu/reference/std_SuperFluxPeaks.html -val EssentiaJS::SuperFluxPeaks(std::vector& input_novelty, const float combine, const float frameRate, const float pre_avg, const float pre_max, const float ratioThreshold, const float threshold) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoSuperFluxPeaks = factory.create("SuperFluxPeaks", "combine", combine, "frameRate", frameRate, "pre_avg", pre_avg, "pre_max", pre_max, "ratioThreshold", ratioThreshold, "threshold", threshold); - algoSuperFluxPeaks->input("novelty").set(input_novelty); - std::vector output_peaks; - algoSuperFluxPeaks->output("peaks").set(output_peaks); - algoSuperFluxPeaks->compute(); - val outputSuperFluxPeaks(val::object()); - outputSuperFluxPeaks.set("peaks", output_peaks); - delete algoSuperFluxPeaks; - return outputSuperFluxPeaks; -} - +SuperFluxPeaks::SuperFluxPeaks(const float combine, const float frameRate, const float pre_avg, const float pre_max, const float ratioThreshold, const float threshold) { + configure(combine, frameRate, pre_avg, pre_max, ratioThreshold, threshold); +} +SuperFluxPeaks::~SuperFluxPeaks() { + delete _superfluxpeaks; +} +void SuperFluxPeaks::configure(const float combine, const float frameRate, const float pre_avg, const float pre_max, const float ratioThreshold, const float threshold) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _superfluxpeaks = factory.create("SuperFluxPeaks", "combine", combine, "frameRate", frameRate, "pre_avg", pre_avg, "pre_max", pre_max, "ratioThreshold", ratioThreshold, "threshold", threshold); +} +val SuperFluxPeaks::compute(std::vector& input_novelty) { + _superfluxpeaks->input("novelty").set(input_novelty); + std::vector output_peaks; + _superfluxpeaks->output("peaks").set(output_peaks); + _superfluxpeaks->compute(); + val outputSuperFluxPeaks(val::object()); + outputSuperFluxPeaks.set("peaks", output_peaks); + return outputSuperFluxPeaks; +} +void SuperFluxPeaks::reset() { +_superfluxpeaks->reset(); +} +// END SuperFluxPeaks definitions + +// START TCToTotal definitions // check https://essentia.upf.edu/reference/std_TCToTotal.html -val EssentiaJS::TCToTotal(std::vector& input_envelope) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTCToTotal = factory.create("TCToTotal"); - algoTCToTotal->input("envelope").set(input_envelope); - float output_TCToTotal; - algoTCToTotal->output("TCToTotal").set(output_TCToTotal); - algoTCToTotal->compute(); - val outputTCToTotal(val::object()); - outputTCToTotal.set("TCToTotal", output_TCToTotal); - delete algoTCToTotal; - return outputTCToTotal; -} - +TCToTotal::TCToTotal() { + configure(); +} +TCToTotal::~TCToTotal() { + delete _tctototal; +} +void TCToTotal::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _tctototal = factory.create("TCToTotal"); +} +val TCToTotal::compute(std::vector& input_envelope) { + _tctototal->input("envelope").set(input_envelope); + float output_TCToTotal; + _tctototal->output("TCToTotal").set(output_TCToTotal); + _tctototal->compute(); + val outputTCToTotal(val::object()); + outputTCToTotal.set("TCToTotal", output_TCToTotal); + return outputTCToTotal; +} +void TCToTotal::reset() { +_tctototal->reset(); +} +// END TCToTotal definitions + +// START TempoScaleBands definitions // check https://essentia.upf.edu/reference/std_TempoScaleBands.html -val EssentiaJS::TempoScaleBands(std::vector& input_bands, const std::vector& bandsGain, const float frameTime) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTempoScaleBands = factory.create("TempoScaleBands", "bandsGain", bandsGain, "frameTime", frameTime); - algoTempoScaleBands->input("bands").set(input_bands); - std::vector output_scaledBands; - float output_cumulativeBands; - algoTempoScaleBands->output("scaledBands").set(output_scaledBands); - algoTempoScaleBands->output("cumulativeBands").set(output_cumulativeBands); - algoTempoScaleBands->compute(); - val outputTempoScaleBands(val::object()); - outputTempoScaleBands.set("scaledBands", output_scaledBands); - outputTempoScaleBands.set("cumulativeBands", output_cumulativeBands); - delete algoTempoScaleBands; - return outputTempoScaleBands; -} - +TempoScaleBands::TempoScaleBands(const std::vector& bandsGain, const float frameTime) { + configure(bandsGain, frameTime); +} +TempoScaleBands::~TempoScaleBands() { + delete _temposcalebands; +} +void TempoScaleBands::configure(const std::vector& bandsGain, const float frameTime) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _temposcalebands = factory.create("TempoScaleBands", "bandsGain", bandsGain, "frameTime", frameTime); +} +val TempoScaleBands::compute(std::vector& input_bands) { + _temposcalebands->input("bands").set(input_bands); + std::vector output_scaledBands; + float output_cumulativeBands; + _temposcalebands->output("scaledBands").set(output_scaledBands); + _temposcalebands->output("cumulativeBands").set(output_cumulativeBands); + _temposcalebands->compute(); + val outputTempoScaleBands(val::object()); + outputTempoScaleBands.set("scaledBands", output_scaledBands); + outputTempoScaleBands.set("cumulativeBands", output_cumulativeBands); + return outputTempoScaleBands; +} +void TempoScaleBands::reset() { +_temposcalebands->reset(); +} +// END TempoScaleBands definitions + +// START TempoTap definitions // check https://essentia.upf.edu/reference/std_TempoTap.html -val EssentiaJS::TempoTap(std::vector& input_featuresFrame, const int frameHop, const int frameSize, const int maxTempo, const int minTempo, const int numberFrames, const float sampleRate, const std::vector& tempoHints) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTempoTap = factory.create("TempoTap", "frameHop", frameHop, "frameSize", frameSize, "maxTempo", maxTempo, "minTempo", minTempo, "numberFrames", numberFrames, "sampleRate", sampleRate, "tempoHints", tempoHints); - algoTempoTap->input("featuresFrame").set(input_featuresFrame); - std::vector output_periods; - std::vector output_phases; - algoTempoTap->output("periods").set(output_periods); - algoTempoTap->output("phases").set(output_phases); - algoTempoTap->compute(); - val outputTempoTap(val::object()); - outputTempoTap.set("periods", output_periods); - outputTempoTap.set("phases", output_phases); - delete algoTempoTap; - return outputTempoTap; -} - +TempoTap::TempoTap(const int frameHop, const int frameSize, const int maxTempo, const int minTempo, const int numberFrames, const float sampleRate, const std::vector& tempoHints) { + configure(frameHop, frameSize, maxTempo, minTempo, numberFrames, sampleRate, tempoHints); +} +TempoTap::~TempoTap() { + delete _tempotap; +} +void TempoTap::configure(const int frameHop, const int frameSize, const int maxTempo, const int minTempo, const int numberFrames, const float sampleRate, const std::vector& tempoHints) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _tempotap = factory.create("TempoTap", "frameHop", frameHop, "frameSize", frameSize, "maxTempo", maxTempo, "minTempo", minTempo, "numberFrames", numberFrames, "sampleRate", sampleRate, "tempoHints", tempoHints); +} +val TempoTap::compute(std::vector& input_featuresFrame) { + _tempotap->input("featuresFrame").set(input_featuresFrame); + std::vector output_periods; + std::vector output_phases; + _tempotap->output("periods").set(output_periods); + _tempotap->output("phases").set(output_phases); + _tempotap->compute(); + val outputTempoTap(val::object()); + outputTempoTap.set("periods", output_periods); + outputTempoTap.set("phases", output_phases); + return outputTempoTap; +} +void TempoTap::reset() { +_tempotap->reset(); +} +// END TempoTap definitions + +// START TempoTapDegara definitions // check https://essentia.upf.edu/reference/std_TempoTapDegara.html -val EssentiaJS::TempoTapDegara(std::vector& input_onsetDetections, const int maxTempo, const int minTempo, const std::string& resample, const float sampleRateODF) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTempoTapDegara = factory.create("TempoTapDegara", "maxTempo", maxTempo, "minTempo", minTempo, "resample", resample, "sampleRateODF", sampleRateODF); - algoTempoTapDegara->input("onsetDetections").set(input_onsetDetections); - std::vector output_ticks; - algoTempoTapDegara->output("ticks").set(output_ticks); - algoTempoTapDegara->compute(); - val outputTempoTapDegara(val::object()); - outputTempoTapDegara.set("ticks", output_ticks); - delete algoTempoTapDegara; - return outputTempoTapDegara; -} - +TempoTapDegara::TempoTapDegara(const int maxTempo, const int minTempo, const std::string& resample, const float sampleRateODF) { + configure(maxTempo, minTempo, resample, sampleRateODF); +} +TempoTapDegara::~TempoTapDegara() { + delete _tempotapdegara; +} +void TempoTapDegara::configure(const int maxTempo, const int minTempo, const std::string& resample, const float sampleRateODF) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _tempotapdegara = factory.create("TempoTapDegara", "maxTempo", maxTempo, "minTempo", minTempo, "resample", resample, "sampleRateODF", sampleRateODF); +} +val TempoTapDegara::compute(std::vector& input_onsetDetections) { + _tempotapdegara->input("onsetDetections").set(input_onsetDetections); + std::vector output_ticks; + _tempotapdegara->output("ticks").set(output_ticks); + _tempotapdegara->compute(); + val outputTempoTapDegara(val::object()); + outputTempoTapDegara.set("ticks", output_ticks); + return outputTempoTapDegara; +} +void TempoTapDegara::reset() { +_tempotapdegara->reset(); +} +// END TempoTapDegara definitions + +// START TempoTapMaxAgreement definitions // check https://essentia.upf.edu/reference/std_TempoTapMaxAgreement.html -val EssentiaJS::TempoTapMaxAgreement(std::vector >& input_tickCandidates) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTempoTapMaxAgreement = factory.create("TempoTapMaxAgreement"); - algoTempoTapMaxAgreement->input("tickCandidates").set(input_tickCandidates); - std::vector output_ticks; - float output_confidence; - algoTempoTapMaxAgreement->output("ticks").set(output_ticks); - algoTempoTapMaxAgreement->output("confidence").set(output_confidence); - algoTempoTapMaxAgreement->compute(); - val outputTempoTapMaxAgreement(val::object()); - outputTempoTapMaxAgreement.set("ticks", output_ticks); - outputTempoTapMaxAgreement.set("confidence", output_confidence); - delete algoTempoTapMaxAgreement; - return outputTempoTapMaxAgreement; -} - +TempoTapMaxAgreement::TempoTapMaxAgreement() { + configure(); +} +TempoTapMaxAgreement::~TempoTapMaxAgreement() { + delete _tempotapmaxagreement; +} +void TempoTapMaxAgreement::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _tempotapmaxagreement = factory.create("TempoTapMaxAgreement"); +} +val TempoTapMaxAgreement::compute(std::vector >& input_tickCandidates) { + _tempotapmaxagreement->input("tickCandidates").set(input_tickCandidates); + std::vector output_ticks; + float output_confidence; + _tempotapmaxagreement->output("ticks").set(output_ticks); + _tempotapmaxagreement->output("confidence").set(output_confidence); + _tempotapmaxagreement->compute(); + val outputTempoTapMaxAgreement(val::object()); + outputTempoTapMaxAgreement.set("ticks", output_ticks); + outputTempoTapMaxAgreement.set("confidence", output_confidence); + return outputTempoTapMaxAgreement; +} +void TempoTapMaxAgreement::reset() { +_tempotapmaxagreement->reset(); +} +// END TempoTapMaxAgreement definitions + +// START TempoTapTicks definitions // check https://essentia.upf.edu/reference/std_TempoTapTicks.html -val EssentiaJS::TempoTapTicks(std::vector& input_periods, std::vector& input_phases, const int frameHop, const int hopSize, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTempoTapTicks = factory.create("TempoTapTicks", "frameHop", frameHop, "hopSize", hopSize, "sampleRate", sampleRate); - algoTempoTapTicks->input("periods").set(input_periods); - algoTempoTapTicks->input("phases").set(input_phases); - std::vector output_ticks; - std::vector output_matchingPeriods; - algoTempoTapTicks->output("ticks").set(output_ticks); - algoTempoTapTicks->output("matchingPeriods").set(output_matchingPeriods); - algoTempoTapTicks->compute(); - val outputTempoTapTicks(val::object()); - outputTempoTapTicks.set("ticks", output_ticks); - outputTempoTapTicks.set("matchingPeriods", output_matchingPeriods); - delete algoTempoTapTicks; - return outputTempoTapTicks; -} - +TempoTapTicks::TempoTapTicks(const int frameHop, const int hopSize, const float sampleRate) { + configure(frameHop, hopSize, sampleRate); +} +TempoTapTicks::~TempoTapTicks() { + delete _tempotapticks; +} +void TempoTapTicks::configure(const int frameHop, const int hopSize, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _tempotapticks = factory.create("TempoTapTicks", "frameHop", frameHop, "hopSize", hopSize, "sampleRate", sampleRate); +} +val TempoTapTicks::compute(std::vector& input_periods, std::vector& input_phases) { + _tempotapticks->input("periods").set(input_periods); + _tempotapticks->input("phases").set(input_phases); + std::vector output_ticks; + std::vector output_matchingPeriods; + _tempotapticks->output("ticks").set(output_ticks); + _tempotapticks->output("matchingPeriods").set(output_matchingPeriods); + _tempotapticks->compute(); + val outputTempoTapTicks(val::object()); + outputTempoTapTicks.set("ticks", output_ticks); + outputTempoTapTicks.set("matchingPeriods", output_matchingPeriods); + return outputTempoTapTicks; +} +void TempoTapTicks::reset() { +_tempotapticks->reset(); +} +// END TempoTapTicks definitions + +// START TensorflowInputFSDSINet definitions +// check https://essentia.upf.edu/reference/std_TensorflowInputFSDSINet.html +TensorflowInputFSDSINet::TensorflowInputFSDSINet() { + configure(); +} +TensorflowInputFSDSINet::~TensorflowInputFSDSINet() { + delete _tensorflowinputfsdsinet; +} +void TensorflowInputFSDSINet::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _tensorflowinputfsdsinet = factory.create("TensorflowInputFSDSINet"); +} +val TensorflowInputFSDSINet::compute(std::vector& input_frame) { + _tensorflowinputfsdsinet->input("frame").set(input_frame); + std::vector output_bands; + _tensorflowinputfsdsinet->output("bands").set(output_bands); + _tensorflowinputfsdsinet->compute(); + val outputTensorflowInputFSDSINet(val::object()); + outputTensorflowInputFSDSINet.set("bands", output_bands); + return outputTensorflowInputFSDSINet; +} +void TensorflowInputFSDSINet::reset() { +_tensorflowinputfsdsinet->reset(); +} +// END TensorflowInputFSDSINet definitions + +// START TensorflowInputMusiCNN definitions // check https://essentia.upf.edu/reference/std_TensorflowInputMusiCNN.html -val EssentiaJS::TensorflowInputMusiCNN(std::vector& input_frame) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTensorflowInputMusiCNN = factory.create("TensorflowInputMusiCNN"); - algoTensorflowInputMusiCNN->input("frame").set(input_frame); - std::vector output_bands; - algoTensorflowInputMusiCNN->output("bands").set(output_bands); - algoTensorflowInputMusiCNN->compute(); - val outputTensorflowInputMusiCNN(val::object()); - outputTensorflowInputMusiCNN.set("bands", output_bands); - delete algoTensorflowInputMusiCNN; - return outputTensorflowInputMusiCNN; -} - +TensorflowInputMusiCNN::TensorflowInputMusiCNN() { + configure(); +} +TensorflowInputMusiCNN::~TensorflowInputMusiCNN() { + delete _tensorflowinputmusicnn; +} +void TensorflowInputMusiCNN::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _tensorflowinputmusicnn = factory.create("TensorflowInputMusiCNN"); +} +val TensorflowInputMusiCNN::compute(std::vector& input_frame) { + _tensorflowinputmusicnn->input("frame").set(input_frame); + std::vector output_bands; + _tensorflowinputmusicnn->output("bands").set(output_bands); + _tensorflowinputmusicnn->compute(); + val outputTensorflowInputMusiCNN(val::object()); + outputTensorflowInputMusiCNN.set("bands", output_bands); + return outputTensorflowInputMusiCNN; +} +void TensorflowInputMusiCNN::reset() { +_tensorflowinputmusicnn->reset(); +} +// END TensorflowInputMusiCNN definitions + +// START TensorflowInputTempoCNN definitions +// check https://essentia.upf.edu/reference/std_TensorflowInputTempoCNN.html +TensorflowInputTempoCNN::TensorflowInputTempoCNN() { + configure(); +} +TensorflowInputTempoCNN::~TensorflowInputTempoCNN() { + delete _tensorflowinputtempocnn; +} +void TensorflowInputTempoCNN::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _tensorflowinputtempocnn = factory.create("TensorflowInputTempoCNN"); +} +val TensorflowInputTempoCNN::compute(std::vector& input_frame) { + _tensorflowinputtempocnn->input("frame").set(input_frame); + std::vector output_bands; + _tensorflowinputtempocnn->output("bands").set(output_bands); + _tensorflowinputtempocnn->compute(); + val outputTensorflowInputTempoCNN(val::object()); + outputTensorflowInputTempoCNN.set("bands", output_bands); + return outputTensorflowInputTempoCNN; +} +void TensorflowInputTempoCNN::reset() { +_tensorflowinputtempocnn->reset(); +} +// END TensorflowInputTempoCNN definitions + +// START TensorflowInputVGGish definitions // check https://essentia.upf.edu/reference/std_TensorflowInputVGGish.html -val EssentiaJS::TensorflowInputVGGish(std::vector& input_frame) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTensorflowInputVGGish = factory.create("TensorflowInputVGGish"); - algoTensorflowInputVGGish->input("frame").set(input_frame); - std::vector output_bands; - algoTensorflowInputVGGish->output("bands").set(output_bands); - algoTensorflowInputVGGish->compute(); - val outputTensorflowInputVGGish(val::object()); - outputTensorflowInputVGGish.set("bands", output_bands); - delete algoTensorflowInputVGGish; - return outputTensorflowInputVGGish; -} - +TensorflowInputVGGish::TensorflowInputVGGish() { + configure(); +} +TensorflowInputVGGish::~TensorflowInputVGGish() { + delete _tensorflowinputvggish; +} +void TensorflowInputVGGish::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _tensorflowinputvggish = factory.create("TensorflowInputVGGish"); +} +val TensorflowInputVGGish::compute(std::vector& input_frame) { + _tensorflowinputvggish->input("frame").set(input_frame); + std::vector output_bands; + _tensorflowinputvggish->output("bands").set(output_bands); + _tensorflowinputvggish->compute(); + val outputTensorflowInputVGGish(val::object()); + outputTensorflowInputVGGish.set("bands", output_bands); + return outputTensorflowInputVGGish; +} +void TensorflowInputVGGish::reset() { +_tensorflowinputvggish->reset(); +} +// END TensorflowInputVGGish definitions + +// START TonalExtractor definitions // check https://essentia.upf.edu/reference/std_TonalExtractor.html -val EssentiaJS::TonalExtractor(std::vector& input_signal, const int frameSize, const int hopSize, const float tuningFrequency) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTonalExtractor = factory.create("TonalExtractor", "frameSize", frameSize, "hopSize", hopSize, "tuningFrequency", tuningFrequency); - algoTonalExtractor->input("signal").set(input_signal); - float output_chords_changes_rate; - std::vector output_chords_histogram; - std::string output_chords_key; - float output_chords_number_rate; - std::vector output_chords_progression; - std::string output_chords_scale; - std::vector output_chords_strength; - std::vector > output_hpcp; - std::vector > output_hpcp_highres; - std::string output_key_key; - std::string output_key_scale; - float output_key_strength; - algoTonalExtractor->output("chords_changes_rate").set(output_chords_changes_rate); - algoTonalExtractor->output("chords_histogram").set(output_chords_histogram); - algoTonalExtractor->output("chords_key").set(output_chords_key); - algoTonalExtractor->output("chords_number_rate").set(output_chords_number_rate); - algoTonalExtractor->output("chords_progression").set(output_chords_progression); - algoTonalExtractor->output("chords_scale").set(output_chords_scale); - algoTonalExtractor->output("chords_strength").set(output_chords_strength); - algoTonalExtractor->output("hpcp").set(output_hpcp); - algoTonalExtractor->output("hpcp_highres").set(output_hpcp_highres); - algoTonalExtractor->output("key_key").set(output_key_key); - algoTonalExtractor->output("key_scale").set(output_key_scale); - algoTonalExtractor->output("key_strength").set(output_key_strength); - algoTonalExtractor->compute(); - val outputTonalExtractor(val::object()); - outputTonalExtractor.set("chords_changes_rate", output_chords_changes_rate); - outputTonalExtractor.set("chords_histogram", output_chords_histogram); - outputTonalExtractor.set("chords_key", output_chords_key); - outputTonalExtractor.set("chords_number_rate", output_chords_number_rate); - outputTonalExtractor.set("chords_progression", output_chords_progression); - outputTonalExtractor.set("chords_scale", output_chords_scale); - outputTonalExtractor.set("chords_strength", output_chords_strength); - outputTonalExtractor.set("hpcp", output_hpcp); - outputTonalExtractor.set("hpcp_highres", output_hpcp_highres); - outputTonalExtractor.set("key_key", output_key_key); - outputTonalExtractor.set("key_scale", output_key_scale); - outputTonalExtractor.set("key_strength", output_key_strength); - delete algoTonalExtractor; - return outputTonalExtractor; -} - +TonalExtractor::TonalExtractor(const int frameSize, const int hopSize, const float tuningFrequency) { + configure(frameSize, hopSize, tuningFrequency); +} +TonalExtractor::~TonalExtractor() { + delete _tonalextractor; +} +void TonalExtractor::configure(const int frameSize, const int hopSize, const float tuningFrequency) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _tonalextractor = factory.create("TonalExtractor", "frameSize", frameSize, "hopSize", hopSize, "tuningFrequency", tuningFrequency); +} +val TonalExtractor::compute(std::vector& input_signal) { + _tonalextractor->input("signal").set(input_signal); + float output_chords_changes_rate; + std::vector output_chords_histogram; + std::string output_chords_key; + float output_chords_number_rate; + std::vector output_chords_progression; + std::string output_chords_scale; + std::vector output_chords_strength; + std::vector > output_hpcp; + std::vector > output_hpcp_highres; + std::string output_key_key; + std::string output_key_scale; + float output_key_strength; + _tonalextractor->output("chords_changes_rate").set(output_chords_changes_rate); + _tonalextractor->output("chords_histogram").set(output_chords_histogram); + _tonalextractor->output("chords_key").set(output_chords_key); + _tonalextractor->output("chords_number_rate").set(output_chords_number_rate); + _tonalextractor->output("chords_progression").set(output_chords_progression); + _tonalextractor->output("chords_scale").set(output_chords_scale); + _tonalextractor->output("chords_strength").set(output_chords_strength); + _tonalextractor->output("hpcp").set(output_hpcp); + _tonalextractor->output("hpcp_highres").set(output_hpcp_highres); + _tonalextractor->output("key_key").set(output_key_key); + _tonalextractor->output("key_scale").set(output_key_scale); + _tonalextractor->output("key_strength").set(output_key_strength); + _tonalextractor->compute(); + val outputTonalExtractor(val::object()); + outputTonalExtractor.set("chords_changes_rate", output_chords_changes_rate); + outputTonalExtractor.set("chords_histogram", output_chords_histogram); + outputTonalExtractor.set("chords_key", output_chords_key); + outputTonalExtractor.set("chords_number_rate", output_chords_number_rate); + outputTonalExtractor.set("chords_progression", output_chords_progression); + outputTonalExtractor.set("chords_scale", output_chords_scale); + outputTonalExtractor.set("chords_strength", output_chords_strength); + outputTonalExtractor.set("hpcp", output_hpcp); + outputTonalExtractor.set("hpcp_highres", output_hpcp_highres); + outputTonalExtractor.set("key_key", output_key_key); + outputTonalExtractor.set("key_scale", output_key_scale); + outputTonalExtractor.set("key_strength", output_key_strength); + return outputTonalExtractor; +} +void TonalExtractor::reset() { +_tonalextractor->reset(); +} +// END TonalExtractor definitions + +// START TonicIndianArtMusic definitions // check https://essentia.upf.edu/reference/std_TonicIndianArtMusic.html -val EssentiaJS::TonicIndianArtMusic(std::vector& input_signal, const float binResolution, const int frameSize, const float harmonicWeight, const int hopSize, const float magnitudeCompression, const float magnitudeThreshold, const float maxTonicFrequency, const float minTonicFrequency, const int numberHarmonics, const int numberSaliencePeaks, const float referenceFrequency, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTonicIndianArtMusic = factory.create("TonicIndianArtMusic", "binResolution", binResolution, "frameSize", frameSize, "harmonicWeight", harmonicWeight, "hopSize", hopSize, "magnitudeCompression", magnitudeCompression, "magnitudeThreshold", magnitudeThreshold, "maxTonicFrequency", maxTonicFrequency, "minTonicFrequency", minTonicFrequency, "numberHarmonics", numberHarmonics, "numberSaliencePeaks", numberSaliencePeaks, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate); - algoTonicIndianArtMusic->input("signal").set(input_signal); - float output_tonic; - algoTonicIndianArtMusic->output("tonic").set(output_tonic); - algoTonicIndianArtMusic->compute(); - val outputTonicIndianArtMusic(val::object()); - outputTonicIndianArtMusic.set("tonic", output_tonic); - delete algoTonicIndianArtMusic; - return outputTonicIndianArtMusic; -} - +TonicIndianArtMusic::TonicIndianArtMusic(const float binResolution, const int frameSize, const float harmonicWeight, const int hopSize, const float magnitudeCompression, const float magnitudeThreshold, const float maxTonicFrequency, const float minTonicFrequency, const int numberHarmonics, const int numberSaliencePeaks, const float referenceFrequency, const float sampleRate) { + configure(binResolution, frameSize, harmonicWeight, hopSize, magnitudeCompression, magnitudeThreshold, maxTonicFrequency, minTonicFrequency, numberHarmonics, numberSaliencePeaks, referenceFrequency, sampleRate); +} +TonicIndianArtMusic::~TonicIndianArtMusic() { + delete _tonicindianartmusic; +} +void TonicIndianArtMusic::configure(const float binResolution, const int frameSize, const float harmonicWeight, const int hopSize, const float magnitudeCompression, const float magnitudeThreshold, const float maxTonicFrequency, const float minTonicFrequency, const int numberHarmonics, const int numberSaliencePeaks, const float referenceFrequency, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _tonicindianartmusic = factory.create("TonicIndianArtMusic", "binResolution", binResolution, "frameSize", frameSize, "harmonicWeight", harmonicWeight, "hopSize", hopSize, "magnitudeCompression", magnitudeCompression, "magnitudeThreshold", magnitudeThreshold, "maxTonicFrequency", maxTonicFrequency, "minTonicFrequency", minTonicFrequency, "numberHarmonics", numberHarmonics, "numberSaliencePeaks", numberSaliencePeaks, "referenceFrequency", referenceFrequency, "sampleRate", sampleRate); +} +val TonicIndianArtMusic::compute(std::vector& input_signal) { + _tonicindianartmusic->input("signal").set(input_signal); + float output_tonic; + _tonicindianartmusic->output("tonic").set(output_tonic); + _tonicindianartmusic->compute(); + val outputTonicIndianArtMusic(val::object()); + outputTonicIndianArtMusic.set("tonic", output_tonic); + return outputTonicIndianArtMusic; +} +void TonicIndianArtMusic::reset() { +_tonicindianartmusic->reset(); +} +// END TonicIndianArtMusic definitions + +// START TriangularBands definitions // check https://essentia.upf.edu/reference/std_TriangularBands.html -val EssentiaJS::TriangularBands(std::vector& input_spectrum, const std::vector& frequencyBands, const int inputSize, const bool log, const std::string& normalize, const float sampleRate, const std::string& type, const std::string& weighting) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTriangularBands = factory.create("TriangularBands", "frequencyBands", frequencyBands, "inputSize", inputSize, "log", log, "normalize", normalize, "sampleRate", sampleRate, "type", type, "weighting", weighting); - algoTriangularBands->input("spectrum").set(input_spectrum); - std::vector output_bands; - algoTriangularBands->output("bands").set(output_bands); - algoTriangularBands->compute(); - val outputTriangularBands(val::object()); - outputTriangularBands.set("bands", output_bands); - delete algoTriangularBands; - return outputTriangularBands; -} - +TriangularBands::TriangularBands(const std::vector& frequencyBands, const int inputSize, const bool log, const std::string& normalize, const float sampleRate, const std::string& type, const std::string& weighting) { + configure(frequencyBands, inputSize, log, normalize, sampleRate, type, weighting); +} +TriangularBands::~TriangularBands() { + delete _triangularbands; +} +void TriangularBands::configure(const std::vector& frequencyBands, const int inputSize, const bool log, const std::string& normalize, const float sampleRate, const std::string& type, const std::string& weighting) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _triangularbands = factory.create("TriangularBands", "frequencyBands", frequencyBands, "inputSize", inputSize, "log", log, "normalize", normalize, "sampleRate", sampleRate, "type", type, "weighting", weighting); +} +val TriangularBands::compute(std::vector& input_spectrum) { + _triangularbands->input("spectrum").set(input_spectrum); + std::vector output_bands; + _triangularbands->output("bands").set(output_bands); + _triangularbands->compute(); + val outputTriangularBands(val::object()); + outputTriangularBands.set("bands", output_bands); + return outputTriangularBands; +} +void TriangularBands::reset() { +_triangularbands->reset(); +} +// END TriangularBands definitions + +// START TriangularBarkBands definitions // check https://essentia.upf.edu/reference/std_TriangularBarkBands.html -val EssentiaJS::TriangularBarkBands(std::vector& input_spectrum, const float highFrequencyBound, const int inputSize, const bool log, const float lowFrequencyBound, const std::string& normalize, const int numberBands, const float sampleRate, const std::string& type, const std::string& weighting) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTriangularBarkBands = factory.create("TriangularBarkBands", "highFrequencyBound", highFrequencyBound, "inputSize", inputSize, "log", log, "lowFrequencyBound", lowFrequencyBound, "normalize", normalize, "numberBands", numberBands, "sampleRate", sampleRate, "type", type, "weighting", weighting); - algoTriangularBarkBands->input("spectrum").set(input_spectrum); - std::vector output_bands; - algoTriangularBarkBands->output("bands").set(output_bands); - algoTriangularBarkBands->compute(); - val outputTriangularBarkBands(val::object()); - outputTriangularBarkBands.set("bands", output_bands); - delete algoTriangularBarkBands; - return outputTriangularBarkBands; -} - +TriangularBarkBands::TriangularBarkBands(const float highFrequencyBound, const int inputSize, const bool log, const float lowFrequencyBound, const std::string& normalize, const int numberBands, const float sampleRate, const std::string& type, const std::string& weighting) { + configure(highFrequencyBound, inputSize, log, lowFrequencyBound, normalize, numberBands, sampleRate, type, weighting); +} +TriangularBarkBands::~TriangularBarkBands() { + delete _triangularbarkbands; +} +void TriangularBarkBands::configure(const float highFrequencyBound, const int inputSize, const bool log, const float lowFrequencyBound, const std::string& normalize, const int numberBands, const float sampleRate, const std::string& type, const std::string& weighting) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _triangularbarkbands = factory.create("TriangularBarkBands", "highFrequencyBound", highFrequencyBound, "inputSize", inputSize, "log", log, "lowFrequencyBound", lowFrequencyBound, "normalize", normalize, "numberBands", numberBands, "sampleRate", sampleRate, "type", type, "weighting", weighting); +} +val TriangularBarkBands::compute(std::vector& input_spectrum) { + _triangularbarkbands->input("spectrum").set(input_spectrum); + std::vector output_bands; + _triangularbarkbands->output("bands").set(output_bands); + _triangularbarkbands->compute(); + val outputTriangularBarkBands(val::object()); + outputTriangularBarkBands.set("bands", output_bands); + return outputTriangularBarkBands; +} +void TriangularBarkBands::reset() { +_triangularbarkbands->reset(); +} +// END TriangularBarkBands definitions + +// START Trimmer definitions // check https://essentia.upf.edu/reference/std_Trimmer.html -val EssentiaJS::Trimmer(std::vector& input_signal, const bool checkRange, const float endTime, const float sampleRate, const float startTime) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTrimmer = factory.create("Trimmer", "checkRange", checkRange, "endTime", endTime, "sampleRate", sampleRate, "startTime", startTime); - algoTrimmer->input("signal").set(input_signal); - std::vector output_signal; - algoTrimmer->output("signal").set(output_signal); - algoTrimmer->compute(); - val outputTrimmer(val::object()); - outputTrimmer.set("signal", output_signal); - delete algoTrimmer; - return outputTrimmer; -} - +Trimmer::Trimmer(const bool checkRange, const float endTime, const float sampleRate, const float startTime) { + configure(checkRange, endTime, sampleRate, startTime); +} +Trimmer::~Trimmer() { + delete _trimmer; +} +void Trimmer::configure(const bool checkRange, const float endTime, const float sampleRate, const float startTime) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _trimmer = factory.create("Trimmer", "checkRange", checkRange, "endTime", endTime, "sampleRate", sampleRate, "startTime", startTime); +} +val Trimmer::compute(std::vector& input_signal) { + _trimmer->input("signal").set(input_signal); + std::vector output_signal; + _trimmer->output("signal").set(output_signal); + _trimmer->compute(); + val outputTrimmer(val::object()); + outputTrimmer.set("signal", output_signal); + return outputTrimmer; +} +void Trimmer::reset() { +_trimmer->reset(); +} +// END Trimmer definitions + +// START Tristimulus definitions // check https://essentia.upf.edu/reference/std_Tristimulus.html -val EssentiaJS::Tristimulus(std::vector& input_frequencies, std::vector& input_magnitudes) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTristimulus = factory.create("Tristimulus"); - algoTristimulus->input("frequencies").set(input_frequencies); - algoTristimulus->input("magnitudes").set(input_magnitudes); - std::vector output_tristimulus; - algoTristimulus->output("tristimulus").set(output_tristimulus); - algoTristimulus->compute(); - val outputTristimulus(val::object()); - outputTristimulus.set("tristimulus", output_tristimulus); - delete algoTristimulus; - return outputTristimulus; -} - +Tristimulus::Tristimulus() { + configure(); +} +Tristimulus::~Tristimulus() { + delete _tristimulus; +} +void Tristimulus::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _tristimulus = factory.create("Tristimulus"); +} +val Tristimulus::compute(std::vector& input_frequencies, std::vector& input_magnitudes) { + _tristimulus->input("frequencies").set(input_frequencies); + _tristimulus->input("magnitudes").set(input_magnitudes); + std::vector output_tristimulus; + _tristimulus->output("tristimulus").set(output_tristimulus); + _tristimulus->compute(); + val outputTristimulus(val::object()); + outputTristimulus.set("tristimulus", output_tristimulus); + return outputTristimulus; +} +void Tristimulus::reset() { +_tristimulus->reset(); +} +// END Tristimulus definitions + +// START TruePeakDetector definitions // check https://essentia.upf.edu/reference/std_TruePeakDetector.html -val EssentiaJS::TruePeakDetector(std::vector& input_signal, const bool blockDC, const bool emphasise, const int oversamplingFactor, const int quality, const float sampleRate, const float threshold, const int version) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTruePeakDetector = factory.create("TruePeakDetector", "blockDC", blockDC, "emphasise", emphasise, "oversamplingFactor", oversamplingFactor, "quality", quality, "sampleRate", sampleRate, "threshold", threshold, "version", version); - algoTruePeakDetector->input("signal").set(input_signal); - std::vector output_peakLocations; - std::vector output_output; - algoTruePeakDetector->output("peakLocations").set(output_peakLocations); - algoTruePeakDetector->output("output").set(output_output); - algoTruePeakDetector->compute(); - val outputTruePeakDetector(val::object()); - outputTruePeakDetector.set("peakLocations", output_peakLocations); - outputTruePeakDetector.set("output", output_output); - delete algoTruePeakDetector; - return outputTruePeakDetector; -} - +TruePeakDetector::TruePeakDetector(const bool blockDC, const bool emphasise, const int oversamplingFactor, const int quality, const float sampleRate, const float threshold, const int version) { + configure(blockDC, emphasise, oversamplingFactor, quality, sampleRate, threshold, version); +} +TruePeakDetector::~TruePeakDetector() { + delete _truepeakdetector; +} +void TruePeakDetector::configure(const bool blockDC, const bool emphasise, const int oversamplingFactor, const int quality, const float sampleRate, const float threshold, const int version) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _truepeakdetector = factory.create("TruePeakDetector", "blockDC", blockDC, "emphasise", emphasise, "oversamplingFactor", oversamplingFactor, "quality", quality, "sampleRate", sampleRate, "threshold", threshold, "version", version); +} +val TruePeakDetector::compute(std::vector& input_signal) { + _truepeakdetector->input("signal").set(input_signal); + std::vector output_peakLocations; + std::vector output_output; + _truepeakdetector->output("peakLocations").set(output_peakLocations); + _truepeakdetector->output("output").set(output_output); + _truepeakdetector->compute(); + val outputTruePeakDetector(val::object()); + outputTruePeakDetector.set("peakLocations", output_peakLocations); + outputTruePeakDetector.set("output", output_output); + return outputTruePeakDetector; +} +void TruePeakDetector::reset() { +_truepeakdetector->reset(); +} +// END TruePeakDetector definitions + +// START TuningFrequency definitions // check https://essentia.upf.edu/reference/std_TuningFrequency.html -val EssentiaJS::TuningFrequency(std::vector& input_frequencies, std::vector& input_magnitudes, const float resolution) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTuningFrequency = factory.create("TuningFrequency", "resolution", resolution); - algoTuningFrequency->input("frequencies").set(input_frequencies); - algoTuningFrequency->input("magnitudes").set(input_magnitudes); - float output_tuningFrequency; - float output_tuningCents; - algoTuningFrequency->output("tuningFrequency").set(output_tuningFrequency); - algoTuningFrequency->output("tuningCents").set(output_tuningCents); - algoTuningFrequency->compute(); - val outputTuningFrequency(val::object()); - outputTuningFrequency.set("tuningFrequency", output_tuningFrequency); - outputTuningFrequency.set("tuningCents", output_tuningCents); - delete algoTuningFrequency; - return outputTuningFrequency; -} - +TuningFrequency::TuningFrequency(const float resolution) { + configure(resolution); +} +TuningFrequency::~TuningFrequency() { + delete _tuningfrequency; +} +void TuningFrequency::configure(const float resolution) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _tuningfrequency = factory.create("TuningFrequency", "resolution", resolution); +} +val TuningFrequency::compute(std::vector& input_frequencies, std::vector& input_magnitudes) { + _tuningfrequency->input("frequencies").set(input_frequencies); + _tuningfrequency->input("magnitudes").set(input_magnitudes); + float output_tuningFrequency; + float output_tuningCents; + _tuningfrequency->output("tuningFrequency").set(output_tuningFrequency); + _tuningfrequency->output("tuningCents").set(output_tuningCents); + _tuningfrequency->compute(); + val outputTuningFrequency(val::object()); + outputTuningFrequency.set("tuningFrequency", output_tuningFrequency); + outputTuningFrequency.set("tuningCents", output_tuningCents); + return outputTuningFrequency; +} +void TuningFrequency::reset() { +_tuningfrequency->reset(); +} +// END TuningFrequency definitions + +// START TuningFrequencyExtractor definitions // check https://essentia.upf.edu/reference/std_TuningFrequencyExtractor.html -val EssentiaJS::TuningFrequencyExtractor(std::vector& input_signal, const int frameSize, const int hopSize) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoTuningFrequencyExtractor = factory.create("TuningFrequencyExtractor", "frameSize", frameSize, "hopSize", hopSize); - algoTuningFrequencyExtractor->input("signal").set(input_signal); - std::vector output_tuningFrequency; - algoTuningFrequencyExtractor->output("tuningFrequency").set(output_tuningFrequency); - algoTuningFrequencyExtractor->compute(); - val outputTuningFrequencyExtractor(val::object()); - outputTuningFrequencyExtractor.set("tuningFrequency", output_tuningFrequency); - delete algoTuningFrequencyExtractor; - return outputTuningFrequencyExtractor; -} - +TuningFrequencyExtractor::TuningFrequencyExtractor(const int frameSize, const int hopSize) { + configure(frameSize, hopSize); +} +TuningFrequencyExtractor::~TuningFrequencyExtractor() { + delete _tuningfrequencyextractor; +} +void TuningFrequencyExtractor::configure(const int frameSize, const int hopSize) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _tuningfrequencyextractor = factory.create("TuningFrequencyExtractor", "frameSize", frameSize, "hopSize", hopSize); +} +val TuningFrequencyExtractor::compute(std::vector& input_signal) { + _tuningfrequencyextractor->input("signal").set(input_signal); + std::vector output_tuningFrequency; + _tuningfrequencyextractor->output("tuningFrequency").set(output_tuningFrequency); + _tuningfrequencyextractor->compute(); + val outputTuningFrequencyExtractor(val::object()); + outputTuningFrequencyExtractor.set("tuningFrequency", output_tuningFrequency); + return outputTuningFrequencyExtractor; +} +void TuningFrequencyExtractor::reset() { +_tuningfrequencyextractor->reset(); +} +// END TuningFrequencyExtractor definitions + +// START UnaryOperator definitions // check https://essentia.upf.edu/reference/std_UnaryOperator.html -val EssentiaJS::UnaryOperator(std::vector& input_array, const float scale, const float shift, const std::string& type) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoUnaryOperator = factory.create("UnaryOperator", "scale", scale, "shift", shift, "type", type); - algoUnaryOperator->input("array").set(input_array); - std::vector output_array; - algoUnaryOperator->output("array").set(output_array); - algoUnaryOperator->compute(); - val outputUnaryOperator(val::object()); - outputUnaryOperator.set("array", output_array); - delete algoUnaryOperator; - return outputUnaryOperator; -} - +UnaryOperator::UnaryOperator(const float scale, const float shift, const std::string& type) { + configure(scale, shift, type); +} +UnaryOperator::~UnaryOperator() { + delete _unaryoperator; +} +void UnaryOperator::configure(const float scale, const float shift, const std::string& type) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _unaryoperator = factory.create("UnaryOperator", "scale", scale, "shift", shift, "type", type); +} +val UnaryOperator::compute(std::vector& input_array) { + _unaryoperator->input("array").set(input_array); + std::vector output_array; + _unaryoperator->output("array").set(output_array); + _unaryoperator->compute(); + val outputUnaryOperator(val::object()); + outputUnaryOperator.set("array", output_array); + return outputUnaryOperator; +} +void UnaryOperator::reset() { +_unaryoperator->reset(); +} +// END UnaryOperator definitions + +// START UnaryOperatorStream definitions // check https://essentia.upf.edu/reference/std_UnaryOperatorStream.html -val EssentiaJS::UnaryOperatorStream(std::vector& input_array, const float scale, const float shift, const std::string& type) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoUnaryOperatorStream = factory.create("UnaryOperatorStream", "scale", scale, "shift", shift, "type", type); - algoUnaryOperatorStream->input("array").set(input_array); - std::vector output_array; - algoUnaryOperatorStream->output("array").set(output_array); - algoUnaryOperatorStream->compute(); - val outputUnaryOperatorStream(val::object()); - outputUnaryOperatorStream.set("array", output_array); - delete algoUnaryOperatorStream; - return outputUnaryOperatorStream; -} - +UnaryOperatorStream::UnaryOperatorStream(const float scale, const float shift, const std::string& type) { + configure(scale, shift, type); +} +UnaryOperatorStream::~UnaryOperatorStream() { + delete _unaryoperatorstream; +} +void UnaryOperatorStream::configure(const float scale, const float shift, const std::string& type) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _unaryoperatorstream = factory.create("UnaryOperatorStream", "scale", scale, "shift", shift, "type", type); +} +val UnaryOperatorStream::compute(std::vector& input_array) { + _unaryoperatorstream->input("array").set(input_array); + std::vector output_array; + _unaryoperatorstream->output("array").set(output_array); + _unaryoperatorstream->compute(); + val outputUnaryOperatorStream(val::object()); + outputUnaryOperatorStream.set("array", output_array); + return outputUnaryOperatorStream; +} +void UnaryOperatorStream::reset() { +_unaryoperatorstream->reset(); +} +// END UnaryOperatorStream definitions + +// START Variance definitions // check https://essentia.upf.edu/reference/std_Variance.html -val EssentiaJS::Variance(std::vector& input_array) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoVariance = factory.create("Variance"); - algoVariance->input("array").set(input_array); - float output_variance; - algoVariance->output("variance").set(output_variance); - algoVariance->compute(); - val outputVariance(val::object()); - outputVariance.set("variance", output_variance); - delete algoVariance; - return outputVariance; -} - +Variance::Variance() { + configure(); +} +Variance::~Variance() { + delete _variance; +} +void Variance::configure() { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _variance = factory.create("Variance"); +} +val Variance::compute(std::vector& input_array) { + _variance->input("array").set(input_array); + float output_variance; + _variance->output("variance").set(output_variance); + _variance->compute(); + val outputVariance(val::object()); + outputVariance.set("variance", output_variance); + return outputVariance; +} +void Variance::reset() { +_variance->reset(); +} +// END Variance definitions + +// START Vibrato definitions // check https://essentia.upf.edu/reference/std_Vibrato.html -val EssentiaJS::Vibrato(std::vector& input_pitch, const float maxExtend, const float maxFrequency, const float minExtend, const float minFrequency, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoVibrato = factory.create("Vibrato", "maxExtend", maxExtend, "maxFrequency", maxFrequency, "minExtend", minExtend, "minFrequency", minFrequency, "sampleRate", sampleRate); - algoVibrato->input("pitch").set(input_pitch); - std::vector output_vibratoFrequency; - std::vector output_vibratoExtend; - algoVibrato->output("vibratoFrequency").set(output_vibratoFrequency); - algoVibrato->output("vibratoExtend").set(output_vibratoExtend); - algoVibrato->compute(); - val outputVibrato(val::object()); - outputVibrato.set("vibratoFrequency", output_vibratoFrequency); - outputVibrato.set("vibratoExtend", output_vibratoExtend); - delete algoVibrato; - return outputVibrato; -} - +Vibrato::Vibrato(const float maxExtend, const float maxFrequency, const float minExtend, const float minFrequency, const float sampleRate) { + configure(maxExtend, maxFrequency, minExtend, minFrequency, sampleRate); +} +Vibrato::~Vibrato() { + delete _vibrato; +} +void Vibrato::configure(const float maxExtend, const float maxFrequency, const float minExtend, const float minFrequency, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _vibrato = factory.create("Vibrato", "maxExtend", maxExtend, "maxFrequency", maxFrequency, "minExtend", minExtend, "minFrequency", minFrequency, "sampleRate", sampleRate); +} +val Vibrato::compute(std::vector& input_pitch) { + _vibrato->input("pitch").set(input_pitch); + std::vector output_vibratoFrequency; + std::vector output_vibratoExtend; + _vibrato->output("vibratoFrequency").set(output_vibratoFrequency); + _vibrato->output("vibratoExtend").set(output_vibratoExtend); + _vibrato->compute(); + val outputVibrato(val::object()); + outputVibrato.set("vibratoFrequency", output_vibratoFrequency); + outputVibrato.set("vibratoExtend", output_vibratoExtend); + return outputVibrato; +} +void Vibrato::reset() { +_vibrato->reset(); +} +// END Vibrato definitions + +// START WarpedAutoCorrelation definitions // check https://essentia.upf.edu/reference/std_WarpedAutoCorrelation.html -val EssentiaJS::WarpedAutoCorrelation(std::vector& input_array, const int maxLag, const float sampleRate) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoWarpedAutoCorrelation = factory.create("WarpedAutoCorrelation", "maxLag", maxLag, "sampleRate", sampleRate); - algoWarpedAutoCorrelation->input("array").set(input_array); - std::vector output_warpedAutoCorrelation; - algoWarpedAutoCorrelation->output("warpedAutoCorrelation").set(output_warpedAutoCorrelation); - algoWarpedAutoCorrelation->compute(); - val outputWarpedAutoCorrelation(val::object()); - outputWarpedAutoCorrelation.set("warpedAutoCorrelation", output_warpedAutoCorrelation); - delete algoWarpedAutoCorrelation; - return outputWarpedAutoCorrelation; -} - +WarpedAutoCorrelation::WarpedAutoCorrelation(const int maxLag, const float sampleRate) { + configure(maxLag, sampleRate); +} +WarpedAutoCorrelation::~WarpedAutoCorrelation() { + delete _warpedautocorrelation; +} +void WarpedAutoCorrelation::configure(const int maxLag, const float sampleRate) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _warpedautocorrelation = factory.create("WarpedAutoCorrelation", "maxLag", maxLag, "sampleRate", sampleRate); +} +val WarpedAutoCorrelation::compute(std::vector& input_array) { + _warpedautocorrelation->input("array").set(input_array); + std::vector output_warpedAutoCorrelation; + _warpedautocorrelation->output("warpedAutoCorrelation").set(output_warpedAutoCorrelation); + _warpedautocorrelation->compute(); + val outputWarpedAutoCorrelation(val::object()); + outputWarpedAutoCorrelation.set("warpedAutoCorrelation", output_warpedAutoCorrelation); + return outputWarpedAutoCorrelation; +} +void WarpedAutoCorrelation::reset() { +_warpedautocorrelation->reset(); +} +// END WarpedAutoCorrelation definitions + +// START Welch definitions // check https://essentia.upf.edu/reference/std_Welch.html -val EssentiaJS::Welch(std::vector& input_frame, const int averagingFrames, const int fftSize, const int frameSize, const float sampleRate, const std::string& scaling, const std::string& windowType) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoWelch = factory.create("Welch", "averagingFrames", averagingFrames, "fftSize", fftSize, "frameSize", frameSize, "sampleRate", sampleRate, "scaling", scaling, "windowType", windowType); - algoWelch->input("frame").set(input_frame); - std::vector output_psd; - algoWelch->output("psd").set(output_psd); - algoWelch->compute(); - val outputWelch(val::object()); - outputWelch.set("psd", output_psd); - delete algoWelch; - return outputWelch; -} - +Welch::Welch(const int averagingFrames, const int fftSize, const int frameSize, const float sampleRate, const std::string& scaling, const std::string& windowType) { + configure(averagingFrames, fftSize, frameSize, sampleRate, scaling, windowType); +} +Welch::~Welch() { + delete _welch; +} +void Welch::configure(const int averagingFrames, const int fftSize, const int frameSize, const float sampleRate, const std::string& scaling, const std::string& windowType) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _welch = factory.create("Welch", "averagingFrames", averagingFrames, "fftSize", fftSize, "frameSize", frameSize, "sampleRate", sampleRate, "scaling", scaling, "windowType", windowType); +} +val Welch::compute(std::vector& input_frame) { + _welch->input("frame").set(input_frame); + std::vector output_psd; + _welch->output("psd").set(output_psd); + _welch->compute(); + val outputWelch(val::object()); + outputWelch.set("psd", output_psd); + return outputWelch; +} +void Welch::reset() { +_welch->reset(); +} +// END Welch definitions + +// START Windowing definitions // check https://essentia.upf.edu/reference/std_Windowing.html -val EssentiaJS::Windowing(std::vector& input_frame, const bool normalized, const int size, const std::string& type, const int zeroPadding, const bool zeroPhase) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoWindowing = factory.create("Windowing", "normalized", normalized, "size", size, "type", type, "zeroPadding", zeroPadding, "zeroPhase", zeroPhase); - algoWindowing->input("frame").set(input_frame); - std::vector output_frame; - algoWindowing->output("frame").set(output_frame); - algoWindowing->compute(); - val outputWindowing(val::object()); - outputWindowing.set("frame", output_frame); - delete algoWindowing; - return outputWindowing; -} - +Windowing::Windowing(const int constantsDecimals, const bool normalized, const int size, const bool splitPadding, const bool symmetric, const std::string& type, const int zeroPadding, const bool zeroPhase) { + configure(constantsDecimals, normalized, size, splitPadding, symmetric, type, zeroPadding, zeroPhase); +} +Windowing::~Windowing() { + delete _windowing; +} +void Windowing::configure(const int constantsDecimals, const bool normalized, const int size, const bool splitPadding, const bool symmetric, const std::string& type, const int zeroPadding, const bool zeroPhase) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _windowing = factory.create("Windowing", "constantsDecimals", constantsDecimals, "normalized", normalized, "size", size, "splitPadding", splitPadding, "symmetric", symmetric, "type", type, "zeroPadding", zeroPadding, "zeroPhase", zeroPhase); +} +val Windowing::compute(std::vector& input_frame) { + _windowing->input("frame").set(input_frame); + std::vector output_frame; + _windowing->output("frame").set(output_frame); + _windowing->compute(); + val outputWindowing(val::object()); + outputWindowing.set("frame", output_frame); + return outputWindowing; +} +void Windowing::reset() { +_windowing->reset(); +} +// END Windowing definitions + +// START ZeroCrossingRate definitions // check https://essentia.upf.edu/reference/std_ZeroCrossingRate.html -val EssentiaJS::ZeroCrossingRate(std::vector& input_signal, const float threshold) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* algoZeroCrossingRate = factory.create("ZeroCrossingRate", "threshold", threshold); - algoZeroCrossingRate->input("signal").set(input_signal); - float output_zeroCrossingRate; - algoZeroCrossingRate->output("zeroCrossingRate").set(output_zeroCrossingRate); - algoZeroCrossingRate->compute(); - val outputZeroCrossingRate(val::object()); - outputZeroCrossingRate.set("zeroCrossingRate", output_zeroCrossingRate); - delete algoZeroCrossingRate; - return outputZeroCrossingRate; +ZeroCrossingRate::ZeroCrossingRate(const float threshold) { + configure(threshold); +} +ZeroCrossingRate::~ZeroCrossingRate() { + delete _zerocrossingrate; +} +void ZeroCrossingRate::configure(const float threshold) { + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _zerocrossingrate = factory.create("ZeroCrossingRate", "threshold", threshold); +} +val ZeroCrossingRate::compute(std::vector& input_signal) { + _zerocrossingrate->input("signal").set(input_signal); + float output_zeroCrossingRate; + _zerocrossingrate->output("zeroCrossingRate").set(output_zeroCrossingRate); + _zerocrossingrate->compute(); + val outputZeroCrossingRate(val::object()); + outputZeroCrossingRate.set("zeroCrossingRate", output_zeroCrossingRate); + return outputZeroCrossingRate; +} +void ZeroCrossingRate::reset() { +_zerocrossingrate->reset(); } +// END ZeroCrossingRate definitions diff --git a/src/python/code_generator.py b/src/python/code_generator.py index 9ccdb01..3d39005 100644 --- a/src/python/code_generator.py +++ b/src/python/code_generator.py @@ -82,10 +82,11 @@ def parse_algorithm_info(algorithm_name, target="header"): output_dict['outputs'] = [] param_dict['params'] = [] output_var_names = list() + param_var_names = list() # create the algorithm object algo = getattr(estd, algorithm_name)() doc_dict = algo.getStruct() - algo_obj = "algo%s" % algorithm_name + algo_obj = f"_{algorithm_name.lower()}" # parse inputs for inp in doc_dict['inputs']: @@ -114,33 +115,20 @@ def parse_algorithm_info(algorithm_name, target="header"): params['name'])) param_dict['params'].append('"%s", %s' % (params['name'], params['name'])) + param_var_names.append(params['name']) # parse outputs # if the algorithm has multiple outputs we construct a void function, otherwise return it's return type - if (len(doc_dict['outputs']) != 1): - func_return_type = "void" - if len(doc_dict['outputs']) > 0: - for out in doc_dict['outputs']: - output_var = "%s %s%s" % (map_types_to_cpp(out['type']), - OUTPUT_PREFIX_ES, - out['name']) - - outputs.append(output_var) - output_var_names.append("%s%s" % (OUTPUT_PREFIX_ES, out['name'])) - output_dict['outputs'].append(' %s->output("%s").set(%s%s);' % (algo_obj, - out['name'], - OUTPUT_PREFIX_ES, - out['name'])) - else: - func_return_type = map_types_to_cpp(doc_dict['outputs'][0]['type']).replace('&', '') + + if len(doc_dict['outputs']) > 0: for out in doc_dict['outputs']: - output_var = "%s %s%s" % (map_types_to_cpp(out['type']), OUTPUT_PREFIX_ES, out['name']) - outputs.append(output_var) - output_var_names.append("%s%s" % (OUTPUT_PREFIX_ES, out['name'])) - output_dict['outputs'].append(' %s->output("%s").set(%s%s);' % (algo_obj, - out['name'], - OUTPUT_PREFIX_ES, - out['name'])) + output_name = out['name'] + output_var_name = f"{OUTPUT_PREFIX_ES}{output_name}" + output_var_type_declaration = f"{map_types_to_cpp(out['type'])} {output_var_name}" + outputs.append(output_var_type_declaration) + output_var_names.append(output_var_name) + output_set_str = f'\t{algo_obj}->output("{output_name}").set({OUTPUT_PREFIX_ES}{output_name});' + output_dict['outputs'].append(output_set_str) # Default class declaration string class_str = f""" @@ -152,7 +140,7 @@ class {algorithm_name} {{ {FUNC_RETURN_TYPE} compute({', '.join(inputs)}); void reset(); private: - Algorithm* _{algorithm_name.lower()}; + Algorithm* {algo_obj}; }};""" # Update the class_str if either inputs or parameters @@ -168,64 +156,72 @@ class {algorithm_name} {{ # otherwise construct the algorithm method elif target == "algorithm": algorithm = list() - class_name = "EssentiaJS" - # add empty line - algorithm.append(" ") - # add comment to the links of documentation - algorithm.append("// check https://essentia.upf.edu/reference/std_%s.html" % algorithm_name) - arg_parse_str = " %s" % algorithm_name + # add comment to the links of documentation + algorithm.append(f"\n// START {algorithm_name} definitions") + algorithm.append(f"// check https://essentia.upf.edu/reference/std_{algorithm_name}.html") - - algorithm.append("%s %s::%s%s {" % (FUNC_RETURN_TYPE, - class_name, - algorithm_name, - class_str.split(arg_parse_str)[1])) - - - algorithm.append(" AlgorithmFactory& factory = standard::AlgorithmFactory::instance();") - + def close_def_body(): + algorithm.append("}") + + # append algo constructor + algorithm.append(f"{algorithm_name}::{algorithm_name}({', '.join(parameters)}) {{") + algorithm.append(f"\tconfigure({', '.join(param_var_names)});") + close_def_body() + + # append algo destructor + algorithm.append(f"{algorithm_name}::~{algorithm_name}() {{") + algorithm.append(f"\tdelete {algo_obj};") + close_def_body() + + # append algo configure: factory instance, algo create + algorithm.append(f"void {algorithm_name}::configure({', '.join(parameters)}) {{") + algorithm.append("\tAlgorithmFactory& factory = standard::AlgorithmFactory::instance();") if param_dict['params']: - algorithm.append(' Algorithm* %s = factory.create("%s", %s);' % (algo_obj, - algorithm_name, - ', '.join(param_dict['params']))) + algorithm.append(f'\t{algo_obj} = factory.create("{algorithm_name}", {", ".join(param_dict["params"])});') else: - algorithm.append(' Algorithm* %s = factory.create("%s");' % (algo_obj, algorithm_name)) + algorithm.append(f'\t{algo_obj} = factory.create("{algorithm_name}");') + close_def_body() + # append algo compute: + algorithm.append(f"{FUNC_RETURN_TYPE} {algorithm_name}::compute({', '.join(inputs)}) {{") # set inputs to the algorithm - for inp in doc_dict['inputs']: - inp_str = ' %s->input("%s").set(%s%s);' % (algo_obj, inp['name'], - INPUT_PREFIX_ES, - inp['name']) - algorithm.append(inp_str) + for input in doc_dict['inputs']: + input_name = input['name'] + input_str = f'\t{algo_obj}->input("{input_name}").set({INPUT_PREFIX_ES}{input_name});' + algorithm.append(input_str) + # declare output containers for out in outputs: - algorithm.append(" %s;" % out.replace('&', '')) - + algorithm.append(f"\t{out.replace('&', '')};") # set outputs to the algorithm if output_dict['outputs']: for out in output_dict['outputs']: algorithm.append(out) else: - raise IOError("No output variable found in the algo '%s'" % algorithm_name) - - algorithm.append(" %s->compute();" % algo_obj) - - algorithm.append(" val output%s(val::object());" % algorithm_name) - + raise IOError(f"No output variable found in the algo '{algorithm_name}'") + # call compute + algorithm.append(f"\t{algo_obj}->compute();") + # declare output val object + algorithm.append(f"\t{FUNC_RETURN_TYPE} output{algorithm_name}(val::object());") + # set its values for out_var in output_var_names: - algorithm.append(' output%s.set("%s", %s);' % (algorithm_name, - out_var.replace(OUTPUT_PREFIX_ES, ''), - out_var)) + output_name = out_var.replace(OUTPUT_PREFIX_ES, '') + algorithm.append(f'\toutput{algorithm_name}.set("{output_name}", {out_var});') + # return + algorithm.append(f"\treturn output{algorithm_name};") + close_def_body() + + # append algo reset: + algorithm.append(f"void {algorithm_name}::reset() {{") + algorithm.append(f"{algo_obj}->reset();") + close_def_body() + algorithm.append(f"// END {algorithm_name} definitions") - algorithm.append(" delete %s;" % algo_obj) - algorithm.append(" return output%s;" % algorithm_name) - algorithm.append("}") return algorithm else: - raise IOError("Given target=%s is not valid. 'target' should be either 'header' or 'algorithm'." - % target) + raise IOError(f"Given target={target} is not valid. 'target' should be either 'header' or 'algorithm'.") def generate_headers(algorithms=TO_INCLUDE_ALGOS): diff --git a/src/python/library.cog b/src/python/library.cog index 7cdc98e..8a2c7c2 100644 --- a/src/python/library.cog +++ b/src/python/library.cog @@ -19,13 +19,9 @@ // NOTE: This source code is machine-generated. -#include -#include #include #include "essentiajs.h" -using namespace essentia; -using namespace essentia::standard; // convert a Float32 JS typed array into std::vector // https://github.com/emscripten-core/emscripten/issues/5519#issuecomment-589702756 @@ -41,48 +37,32 @@ std::vector float32ArrayToVector(const val &arr) { return vec; } -// instantiating the essentia algo registry with an optional argument to enable debug mode -EssentiaJS::EssentiaJS(bool debugger) { - if (debugger) { - // if true sets essentia debugger active - // EAll is a special value in essentia that contains all modules - setDebugLevel(EAll); - unsetDebugLevel(EMemory | EConnectors); - // activate warnings - essentia::warningLevelActive = true; - // activate info - essentia::infoLevelActive = true; - // activate error level - essentia::errorLevelActive = true; - } else { - essentia::infoLevelActive = false; - essentia::warningLevelActive = false; - } - essentia::init(); - essentiaVersion = essentia::version; -} -// shutdown essentia instance -void EssentiaJS::shutdown() { - essentia::shutdown(); +// START FrameGenerator definitions +FrameGenerator::FrameGenerator(int frameSize, int hopSize) { + configure(frameSize, hopSize); } - -// Method for frameCutting the given audio signal -std::vector > EssentiaJS::FrameGenerator(const val& signalArray, int frameSize, int hopSize) { +FrameGenerator::~FrameGenerator() { + delete _framecutter; +} +void FrameGenerator::configure(int frameSize, int hopSize) { + // create algorithm instances + AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + _framecutter = factory.create("FrameCutter", + "frameSize", frameSize, + "hopSize", hopSize); +} +std::vector > FrameGenerator::compute(const val& signalArray) { // convert JS typed typed float 32 array to std::vector std::vector signal = float32ArrayToVector(signalArray); - // create algorithm instances - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - Algorithm* fc = factory.create("FrameCutter", - "frameSize", frameSize, - "hopSize", hopSize); + Pool pool; std::vector frame; - fc->input("signal").set(signal); - fc->output("frame").set(frame); + _framecutter->input("signal").set(signal); + _framecutter->output("frame").set(frame); while (true) { // compute a frame - fc->compute(); + _framecutter->compute(); // if it was the last one (ie: it was empty), then we're done. if (!frame.size()) { break; @@ -91,72 +71,77 @@ std::vector > EssentiaJS::FrameGenerator(const val& signalArr if (isSilent(frame)) continue; pool.add("frames", frame); } - delete fc; - return pool.value > >("frames"); + + return pool.value< std::vector > >("frames"); +} + +void FrameGenerator::reset() { + _framecutter->reset(); } +// END FrameGenerator definitions // This a wrapper for MonoMixer algorithm to accept both left and right channels to downmix an stereo channel input to mono // check https://essentia.upf.edu/reference/std_MonoMixer.html for algorithm details // TODO: could be reimplemented with BinaryOperator and UnaryOperator in the future -val EssentiaJS::MonoMixer(std::vector& left_channel, std::vector& right_channel) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - - // TODO: remove this stereosample cresting overhead in future - Algorithm* algoStereoMuxer = factory.create("StereoMuxer"); - algoStereoMuxer->input("left").set(left_channel); - algoStereoMuxer->input("right").set(right_channel); - std::vector stereoSignal; - algoStereoMuxer->output("audio").set(stereoSignal); - algoStereoMuxer->compute(); - delete algoStereoMuxer; - - Algorithm* algoMonoMixer = factory.create("MonoMixer"); - std::vector output_audio; - algoMonoMixer->input("audio").set(stereoSignal); - // set numberChannels=2 since we only deal with stereo signal in this wrapper - algoMonoMixer->input("numberChannels").set(2); - algoMonoMixer->output("audio").set(output_audio); - algoMonoMixer->compute(); - - val outputMonoMixer(val::object()); - outputMonoMixer.set("audio", output_audio); - delete algoMonoMixer; - return outputMonoMixer; -}; +// val EssentiaJS::MonoMixer(std::vector& left_channel, std::vector& right_channel) { +// AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + +// // TODO: remove this stereosample cresting overhead in future +// Algorithm* algoStereoMuxer = factory.create("StereoMuxer"); +// algoStereoMuxer->input("left").set(left_channel); +// algoStereoMuxer->input("right").set(right_channel); +// std::vector stereoSignal; +// algoStereoMuxer->output("audio").set(stereoSignal); +// algoStereoMuxer->compute(); +// delete algoStereoMuxer; + +// Algorithm* algoMonoMixer = factory.create("MonoMixer"); +// std::vector output_audio; +// algoMonoMixer->input("audio").set(stereoSignal); +// // set numberChannels=2 since we only deal with stereo signal in this wrapper +// algoMonoMixer->input("numberChannels").set(2); +// algoMonoMixer->output("audio").set(output_audio); +// algoMonoMixer->compute(); + +// val outputMonoMixer(val::object()); +// outputMonoMixer.set("audio", output_audio); +// delete algoMonoMixer; +// return outputMonoMixer; +// }; // This a wrapper for LoudnessEBUR128 algorithm to accept both left and right channels of an stereo audio signal seperately // check https://essentia.upf.edu/reference/std_LoudnessEBUR128.html for algorithm details -val EssentiaJS::LoudnessEBUR128(std::vector& left_channel, std::vector& right_channel, const float hopSize, const float sampleRate, const bool startAtZero) { - AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); - - Algorithm* algoStereoMuxer = factory.create("StereoMuxer"); - algoStereoMuxer->input("left").set(left_channel); - algoStereoMuxer->input("right").set(right_channel); - std::vector stereoSignal; - algoStereoMuxer->output("audio").set(stereoSignal); - algoStereoMuxer->compute(); - delete algoStereoMuxer; - - Algorithm* algoLoudnessEBUR128 = factory.create("LoudnessEBUR128", "hopSize", hopSize, "sampleRate", sampleRate, "startAtZero", startAtZero); - algoLoudnessEBUR128->input("signal").set(stereoSignal); - std::vector output_momentaryLoudness; - std::vector output_shortTermLoudness; - float output_integratedLoudness; - float output_loudnessRange; - algoLoudnessEBUR128->output("momentaryLoudness").set(output_momentaryLoudness); - algoLoudnessEBUR128->output("shortTermLoudness").set(output_shortTermLoudness); - algoLoudnessEBUR128->output("integratedLoudness").set(output_integratedLoudness); - algoLoudnessEBUR128->output("loudnessRange").set(output_loudnessRange); - algoLoudnessEBUR128->compute(); - val outputLoudnessEBUR128(val::object()); - outputLoudnessEBUR128.set("momentaryLoudness", output_momentaryLoudness); - outputLoudnessEBUR128.set("shortTermLoudness", output_shortTermLoudness); - outputLoudnessEBUR128.set("integratedLoudness", output_integratedLoudness); - outputLoudnessEBUR128.set("loudnessRange", output_loudnessRange); - - delete algoLoudnessEBUR128; - return outputLoudnessEBUR128; -} +// val EssentiaJS::LoudnessEBUR128(std::vector& left_channel, std::vector& right_channel, const float hopSize, const float sampleRate, const bool startAtZero) { +// AlgorithmFactory& factory = standard::AlgorithmFactory::instance(); + +// Algorithm* algoStereoMuxer = factory.create("StereoMuxer"); +// algoStereoMuxer->input("left").set(left_channel); +// algoStereoMuxer->input("right").set(right_channel); +// std::vector stereoSignal; +// algoStereoMuxer->output("audio").set(stereoSignal); +// algoStereoMuxer->compute(); +// delete algoStereoMuxer; + +// Algorithm* algoLoudnessEBUR128 = factory.create("LoudnessEBUR128", "hopSize", hopSize, "sampleRate", sampleRate, "startAtZero", startAtZero); +// algoLoudnessEBUR128->input("signal").set(stereoSignal); +// std::vector output_momentaryLoudness; +// std::vector output_shortTermLoudness; +// float output_integratedLoudness; +// float output_loudnessRange; +// algoLoudnessEBUR128->output("momentaryLoudness").set(output_momentaryLoudness); +// algoLoudnessEBUR128->output("shortTermLoudness").set(output_shortTermLoudness); +// algoLoudnessEBUR128->output("integratedLoudness").set(output_integratedLoudness); +// algoLoudnessEBUR128->output("loudnessRange").set(output_loudnessRange); +// algoLoudnessEBUR128->compute(); +// val outputLoudnessEBUR128(val::object()); +// outputLoudnessEBUR128.set("momentaryLoudness", output_momentaryLoudness); +// outputLoudnessEBUR128.set("shortTermLoudness", output_shortTermLoudness); +// outputLoudnessEBUR128.set("integratedLoudness", output_integratedLoudness); +// outputLoudnessEBUR128.set("loudnessRange", output_loudnessRange); + +// delete algoLoudnessEBUR128; +// return outputLoudnessEBUR128; +// } // NOTE: The following code snippets are machine generated. Do not edit. /*[[[cog From 50667101bd698add018ce7a5f2bc8ed8838e090f Mon Sep 17 00:00:00 2001 From: Jorge Marcos Date: Tue, 13 Feb 2024 11:05:06 +0100 Subject: [PATCH 03/18] add class-based essentia algo bindings template and code_generator code --- src/cpp/bindings_essentiajs.cpp | 1627 +++++++++++++++++++++++++++---- src/cpp/includes/essentiajs.h | 1 - src/python/bindings.cog | 39 +- src/python/code_generator.py | 53 +- src/python/header.cog | 1 - 5 files changed, 1472 insertions(+), 249 deletions(-) diff --git a/src/cpp/bindings_essentiajs.cpp b/src/cpp/bindings_essentiajs.cpp index 0f558bf..b3abb3a 100644 --- a/src/cpp/bindings_essentiajs.cpp +++ b/src/cpp/bindings_essentiajs.cpp @@ -18,220 +18,1427 @@ */ // NOTE: This source code is auto-generated. - +#include #include "./includes/essentiajs.h" // expose essentiajs class to js using embind wrappers -EMSCRIPTEN_BINDINGS(CLASS_EssentiaJS) { - // NOTE: The following code snippets are machine generated. Do not edit. - class_("EssentiaJS") - .constructor() - .property("version", &EssentiaJS::essentiaVersion) - .property("algorithmNames", &EssentiaJS::algorithmNames) - .function("shutdown", &EssentiaJS::shutdown) - .function("FrameGenerator", &EssentiaJS::FrameGenerator) - .function("MonoMixer", &EssentiaJS::MonoMixer) - .function("LoudnessEBUR128", &EssentiaJS::LoudnessEBUR128) - .function("AfterMaxToBeforeMaxEnergyRatio", &EssentiaJS::AfterMaxToBeforeMaxEnergyRatio) - .function("AllPass", &EssentiaJS::AllPass) - .function("AudioOnsetsMarker", &EssentiaJS::AudioOnsetsMarker) - .function("AutoCorrelation", &EssentiaJS::AutoCorrelation) - .function("BFCC", &EssentiaJS::BFCC) - .function("BPF", &EssentiaJS::BPF) - .function("BandPass", &EssentiaJS::BandPass) - .function("BandReject", &EssentiaJS::BandReject) - .function("BarkBands", &EssentiaJS::BarkBands) - .function("BeatTrackerDegara", &EssentiaJS::BeatTrackerDegara) - .function("BeatTrackerMultiFeature", &EssentiaJS::BeatTrackerMultiFeature) - .function("Beatogram", &EssentiaJS::Beatogram) - .function("BeatsLoudness", &EssentiaJS::BeatsLoudness) - .function("BinaryOperator", &EssentiaJS::BinaryOperator) - .function("BinaryOperatorStream", &EssentiaJS::BinaryOperatorStream) - .function("BpmHistogramDescriptors", &EssentiaJS::BpmHistogramDescriptors) - .function("BpmRubato", &EssentiaJS::BpmRubato) - .function("CentralMoments", &EssentiaJS::CentralMoments) - .function("Centroid", &EssentiaJS::Centroid) - .function("ChordsDescriptors", &EssentiaJS::ChordsDescriptors) - .function("ChordsDetection", &EssentiaJS::ChordsDetection) - .function("ChordsDetectionBeats", &EssentiaJS::ChordsDetectionBeats) - .function("ChromaCrossSimilarity", &EssentiaJS::ChromaCrossSimilarity) - .function("Chromagram", &EssentiaJS::Chromagram) - .function("ClickDetector", &EssentiaJS::ClickDetector) - .function("Clipper", &EssentiaJS::Clipper) - .function("CoverSongSimilarity", &EssentiaJS::CoverSongSimilarity) - .function("Crest", &EssentiaJS::Crest) - .function("CrossCorrelation", &EssentiaJS::CrossCorrelation) - .function("CrossSimilarityMatrix", &EssentiaJS::CrossSimilarityMatrix) - .function("CubicSpline", &EssentiaJS::CubicSpline) - .function("DCRemoval", &EssentiaJS::DCRemoval) - .function("DCT", &EssentiaJS::DCT) - .function("Danceability", &EssentiaJS::Danceability) - .function("Decrease", &EssentiaJS::Decrease) - .function("Derivative", &EssentiaJS::Derivative) - .function("DerivativeSFX", &EssentiaJS::DerivativeSFX) - .function("DiscontinuityDetector", &EssentiaJS::DiscontinuityDetector) - .function("Dissonance", &EssentiaJS::Dissonance) - .function("DistributionShape", &EssentiaJS::DistributionShape) - .function("Duration", &EssentiaJS::Duration) - .function("DynamicComplexity", &EssentiaJS::DynamicComplexity) - .function("ERBBands", &EssentiaJS::ERBBands) - .function("EffectiveDuration", &EssentiaJS::EffectiveDuration) - .function("Energy", &EssentiaJS::Energy) - .function("EnergyBand", &EssentiaJS::EnergyBand) - .function("EnergyBandRatio", &EssentiaJS::EnergyBandRatio) - .function("Entropy", &EssentiaJS::Entropy) - .function("Envelope", &EssentiaJS::Envelope) - .function("EqualLoudness", &EssentiaJS::EqualLoudness) - .function("Flatness", &EssentiaJS::Flatness) - .function("FlatnessDB", &EssentiaJS::FlatnessDB) - .function("FlatnessSFX", &EssentiaJS::FlatnessSFX) - .function("Flux", &EssentiaJS::Flux) - .function("FrameCutter", &EssentiaJS::FrameCutter) - .function("FrameToReal", &EssentiaJS::FrameToReal) - .function("FrequencyBands", &EssentiaJS::FrequencyBands) - .function("GFCC", &EssentiaJS::GFCC) - .function("GapsDetector", &EssentiaJS::GapsDetector) - .function("GeometricMean", &EssentiaJS::GeometricMean) - .function("HFC", &EssentiaJS::HFC) - .function("HPCP", &EssentiaJS::HPCP) - .function("HarmonicBpm", &EssentiaJS::HarmonicBpm) - .function("HarmonicPeaks", &EssentiaJS::HarmonicPeaks) - .function("HighPass", &EssentiaJS::HighPass) - .function("HighResolutionFeatures", &EssentiaJS::HighResolutionFeatures) - .function("Histogram", &EssentiaJS::Histogram) - .function("HprModelAnal", &EssentiaJS::HprModelAnal) - .function("HpsModelAnal", &EssentiaJS::HpsModelAnal) - .function("IDCT", &EssentiaJS::IDCT) - .function("IIR", &EssentiaJS::IIR) - .function("Inharmonicity", &EssentiaJS::Inharmonicity) - .function("InstantPower", &EssentiaJS::InstantPower) - .function("Intensity", &EssentiaJS::Intensity) - .function("Key", &EssentiaJS::Key) - .function("KeyExtractor", &EssentiaJS::KeyExtractor) - .function("LPC", &EssentiaJS::LPC) - .function("Larm", &EssentiaJS::Larm) - .function("Leq", &EssentiaJS::Leq) - .function("LevelExtractor", &EssentiaJS::LevelExtractor) - .function("LogAttackTime", &EssentiaJS::LogAttackTime) - .function("LogSpectrum", &EssentiaJS::LogSpectrum) - .function("LoopBpmConfidence", &EssentiaJS::LoopBpmConfidence) - .function("LoopBpmEstimator", &EssentiaJS::LoopBpmEstimator) - .function("Loudness", &EssentiaJS::Loudness) - .function("LoudnessVickers", &EssentiaJS::LoudnessVickers) - .function("LowLevelSpectralEqloudExtractor", &EssentiaJS::LowLevelSpectralEqloudExtractor) - .function("LowLevelSpectralExtractor", &EssentiaJS::LowLevelSpectralExtractor) - .function("LowPass", &EssentiaJS::LowPass) - .function("MFCC", &EssentiaJS::MFCC) - .function("MaxFilter", &EssentiaJS::MaxFilter) - .function("MaxMagFreq", &EssentiaJS::MaxMagFreq) - .function("MaxToTotal", &EssentiaJS::MaxToTotal) - .function("Mean", &EssentiaJS::Mean) - .function("Median", &EssentiaJS::Median) - .function("MedianFilter", &EssentiaJS::MedianFilter) - .function("MelBands", &EssentiaJS::MelBands) - .function("Meter", &EssentiaJS::Meter) - .function("MinMax", &EssentiaJS::MinMax) - .function("MinToTotal", &EssentiaJS::MinToTotal) - .function("MovingAverage", &EssentiaJS::MovingAverage) - .function("MultiPitchKlapuri", &EssentiaJS::MultiPitchKlapuri) - .function("MultiPitchMelodia", &EssentiaJS::MultiPitchMelodia) - .function("Multiplexer", &EssentiaJS::Multiplexer) - .function("NNLSChroma", &EssentiaJS::NNLSChroma) - .function("NoiseAdder", &EssentiaJS::NoiseAdder) - .function("NoiseBurstDetector", &EssentiaJS::NoiseBurstDetector) - .function("NoveltyCurve", &EssentiaJS::NoveltyCurve) - .function("NoveltyCurveFixedBpmEstimator", &EssentiaJS::NoveltyCurveFixedBpmEstimator) - .function("OddToEvenHarmonicEnergyRatio", &EssentiaJS::OddToEvenHarmonicEnergyRatio) - .function("OnsetDetection", &EssentiaJS::OnsetDetection) - .function("OnsetDetectionGlobal", &EssentiaJS::OnsetDetectionGlobal) - .function("OnsetRate", &EssentiaJS::OnsetRate) - .function("OverlapAdd", &EssentiaJS::OverlapAdd) - .function("PeakDetection", &EssentiaJS::PeakDetection) - .function("PercivalBpmEstimator", &EssentiaJS::PercivalBpmEstimator) - .function("PercivalEnhanceHarmonics", &EssentiaJS::PercivalEnhanceHarmonics) - .function("PercivalEvaluatePulseTrains", &EssentiaJS::PercivalEvaluatePulseTrains) - .function("PitchContourSegmentation", &EssentiaJS::PitchContourSegmentation) - .function("PitchContours", &EssentiaJS::PitchContours) - .function("PitchContoursMelody", &EssentiaJS::PitchContoursMelody) - .function("PitchContoursMonoMelody", &EssentiaJS::PitchContoursMonoMelody) - .function("PitchContoursMultiMelody", &EssentiaJS::PitchContoursMultiMelody) - .function("PitchFilter", &EssentiaJS::PitchFilter) - .function("PitchMelodia", &EssentiaJS::PitchMelodia) - .function("PitchSalience", &EssentiaJS::PitchSalience) - .function("PitchSalienceFunction", &EssentiaJS::PitchSalienceFunction) - .function("PitchSalienceFunctionPeaks", &EssentiaJS::PitchSalienceFunctionPeaks) - .function("PitchYin", &EssentiaJS::PitchYin) - .function("PitchYinFFT", &EssentiaJS::PitchYinFFT) - .function("PitchYinProbabilistic", &EssentiaJS::PitchYinProbabilistic) - .function("PitchYinProbabilities", &EssentiaJS::PitchYinProbabilities) - .function("PitchYinProbabilitiesHMM", &EssentiaJS::PitchYinProbabilitiesHMM) - .function("PowerMean", &EssentiaJS::PowerMean) - .function("PowerSpectrum", &EssentiaJS::PowerSpectrum) - .function("PredominantPitchMelodia", &EssentiaJS::PredominantPitchMelodia) - .function("RMS", &EssentiaJS::RMS) - .function("RawMoments", &EssentiaJS::RawMoments) - .function("ReplayGain", &EssentiaJS::ReplayGain) - .function("Resample", &EssentiaJS::Resample) - .function("ResampleFFT", &EssentiaJS::ResampleFFT) - .function("RhythmDescriptors", &EssentiaJS::RhythmDescriptors) - .function("RhythmExtractor", &EssentiaJS::RhythmExtractor) - .function("RhythmExtractor2013", &EssentiaJS::RhythmExtractor2013) - .function("RhythmTransform", &EssentiaJS::RhythmTransform) - .function("RollOff", &EssentiaJS::RollOff) - .function("SNR", &EssentiaJS::SNR) - .function("SaturationDetector", &EssentiaJS::SaturationDetector) - .function("Scale", &EssentiaJS::Scale) - .function("SineSubtraction", &EssentiaJS::SineSubtraction) - .function("SingleBeatLoudness", &EssentiaJS::SingleBeatLoudness) - .function("Slicer", &EssentiaJS::Slicer) - .function("SpectralCentroidTime", &EssentiaJS::SpectralCentroidTime) - .function("SpectralComplexity", &EssentiaJS::SpectralComplexity) - .function("SpectralContrast", &EssentiaJS::SpectralContrast) - .function("SpectralPeaks", &EssentiaJS::SpectralPeaks) - .function("SpectralWhitening", &EssentiaJS::SpectralWhitening) - .function("Spectrum", &EssentiaJS::Spectrum) - .function("SpectrumCQ", &EssentiaJS::SpectrumCQ) - .function("SpectrumToCent", &EssentiaJS::SpectrumToCent) - .function("Spline", &EssentiaJS::Spline) - .function("SprModelAnal", &EssentiaJS::SprModelAnal) - .function("SprModelSynth", &EssentiaJS::SprModelSynth) - .function("SpsModelAnal", &EssentiaJS::SpsModelAnal) - .function("SpsModelSynth", &EssentiaJS::SpsModelSynth) - .function("StartStopCut", &EssentiaJS::StartStopCut) - .function("StartStopSilence", &EssentiaJS::StartStopSilence) - .function("StochasticModelAnal", &EssentiaJS::StochasticModelAnal) - .function("StochasticModelSynth", &EssentiaJS::StochasticModelSynth) - .function("StrongDecay", &EssentiaJS::StrongDecay) - .function("StrongPeak", &EssentiaJS::StrongPeak) - .function("SuperFluxExtractor", &EssentiaJS::SuperFluxExtractor) - .function("SuperFluxNovelty", &EssentiaJS::SuperFluxNovelty) - .function("SuperFluxPeaks", &EssentiaJS::SuperFluxPeaks) - .function("TCToTotal", &EssentiaJS::TCToTotal) - .function("TempoScaleBands", &EssentiaJS::TempoScaleBands) - .function("TempoTap", &EssentiaJS::TempoTap) - .function("TempoTapDegara", &EssentiaJS::TempoTapDegara) - .function("TempoTapMaxAgreement", &EssentiaJS::TempoTapMaxAgreement) - .function("TempoTapTicks", &EssentiaJS::TempoTapTicks) - .function("TensorflowInputMusiCNN", &EssentiaJS::TensorflowInputMusiCNN) - .function("TensorflowInputVGGish", &EssentiaJS::TensorflowInputVGGish) - .function("TonalExtractor", &EssentiaJS::TonalExtractor) - .function("TonicIndianArtMusic", &EssentiaJS::TonicIndianArtMusic) - .function("TriangularBands", &EssentiaJS::TriangularBands) - .function("TriangularBarkBands", &EssentiaJS::TriangularBarkBands) - .function("Trimmer", &EssentiaJS::Trimmer) - .function("Tristimulus", &EssentiaJS::Tristimulus) - .function("TruePeakDetector", &EssentiaJS::TruePeakDetector) - .function("TuningFrequency", &EssentiaJS::TuningFrequency) - .function("TuningFrequencyExtractor", &EssentiaJS::TuningFrequencyExtractor) - .function("UnaryOperator", &EssentiaJS::UnaryOperator) - .function("UnaryOperatorStream", &EssentiaJS::UnaryOperatorStream) - .function("Variance", &EssentiaJS::Variance) - .function("Vibrato", &EssentiaJS::Vibrato) - .function("WarpedAutoCorrelation", &EssentiaJS::WarpedAutoCorrelation) - .function("Welch", &EssentiaJS::Welch) - .function("Windowing", &EssentiaJS::Windowing) - .function("ZeroCrossingRate", &EssentiaJS::ZeroCrossingRate) +EMSCRIPTEN_BINDINGS(CLASS_EssentiaJS) { + function("bootEssentia", &bootEssentia); + class_("FrameGenerator") + .constructor() + .function("configure", &FrameGenerator::configure) + .function("compute", &FrameGenerator::compute) + .function("reset", &FrameGenerator::reset) + .function("shutdown", &FrameGenerator::shutdown) ; + // NOTE: The following code snippets are machine generated. Do not edit. + + class_("AfterMaxToBeforeMaxEnergyRatio") + .constructor<>() + .function("configure", &AfterMaxToBeforeMaxEnergyRatio::configure) + .function("compute", &AfterMaxToBeforeMaxEnergyRatio::compute) + .function("reset", &AfterMaxToBeforeMaxEnergyRatio::reset) + ; + + class_("AllPass") + .constructor() + .function("configure", &AllPass::configure) + .function("compute", &AllPass::compute) + .function("reset", &AllPass::reset) + ; + + class_("AudioOnsetsMarker") + .constructor&, float, std::string>() + .function("configure", &AudioOnsetsMarker::configure) + .function("compute", &AudioOnsetsMarker::compute) + .function("reset", &AudioOnsetsMarker::reset) + ; + + class_("AutoCorrelation") + .constructor() + .function("configure", &AutoCorrelation::configure) + .function("compute", &AutoCorrelation::compute) + .function("reset", &AutoCorrelation::reset) + ; + + class_("BFCC") + .constructor() + .function("configure", &BFCC::configure) + .function("compute", &BFCC::compute) + .function("reset", &BFCC::reset) + ; + + class_("BPF") + .constructor&, std::vector&>() + .function("configure", &BPF::configure) + .function("compute", &BPF::compute) + .function("reset", &BPF::reset) + ; + + class_("BandPass") + .constructor() + .function("configure", &BandPass::configure) + .function("compute", &BandPass::compute) + .function("reset", &BandPass::reset) + ; + + class_("BandReject") + .constructor() + .function("configure", &BandReject::configure) + .function("compute", &BandReject::compute) + .function("reset", &BandReject::reset) + ; + + class_("BarkBands") + .constructor() + .function("configure", &BarkBands::configure) + .function("compute", &BarkBands::compute) + .function("reset", &BarkBands::reset) + ; + + class_("BeatTrackerDegara") + .constructor() + .function("configure", &BeatTrackerDegara::configure) + .function("compute", &BeatTrackerDegara::compute) + .function("reset", &BeatTrackerDegara::reset) + ; + + class_("BeatTrackerMultiFeature") + .constructor() + .function("configure", &BeatTrackerMultiFeature::configure) + .function("compute", &BeatTrackerMultiFeature::compute) + .function("reset", &BeatTrackerMultiFeature::reset) + ; + + class_("Beatogram") + .constructor() + .function("configure", &Beatogram::configure) + .function("compute", &Beatogram::compute) + .function("reset", &Beatogram::reset) + ; + + class_("BeatsLoudness") + .constructor&, std::vector&, float>() + .function("configure", &BeatsLoudness::configure) + .function("compute", &BeatsLoudness::compute) + .function("reset", &BeatsLoudness::reset) + ; + + class_("BinaryOperator") + .constructor() + .function("configure", &BinaryOperator::configure) + .function("compute", &BinaryOperator::compute) + .function("reset", &BinaryOperator::reset) + ; + + class_("BinaryOperatorStream") + .constructor() + .function("configure", &BinaryOperatorStream::configure) + .function("compute", &BinaryOperatorStream::compute) + .function("reset", &BinaryOperatorStream::reset) + ; + + class_("BpmHistogramDescriptors") + .constructor<>() + .function("configure", &BpmHistogramDescriptors::configure) + .function("compute", &BpmHistogramDescriptors::compute) + .function("reset", &BpmHistogramDescriptors::reset) + ; + + class_("BpmRubato") + .constructor() + .function("configure", &BpmRubato::configure) + .function("compute", &BpmRubato::compute) + .function("reset", &BpmRubato::reset) + ; + + class_("CentralMoments") + .constructor() + .function("configure", &CentralMoments::configure) + .function("compute", &CentralMoments::compute) + .function("reset", &CentralMoments::reset) + ; + + class_("Centroid") + .constructor() + .function("configure", &Centroid::configure) + .function("compute", &Centroid::compute) + .function("reset", &Centroid::reset) + ; + + class_("ChordsDescriptors") + .constructor<>() + .function("configure", &ChordsDescriptors::configure) + .function("compute", &ChordsDescriptors::compute) + .function("reset", &ChordsDescriptors::reset) + ; + + class_("ChordsDetection") + .constructor() + .function("configure", &ChordsDetection::configure) + .function("compute", &ChordsDetection::compute) + .function("reset", &ChordsDetection::reset) + ; + + class_("ChordsDetectionBeats") + .constructor() + .function("configure", &ChordsDetectionBeats::configure) + .function("compute", &ChordsDetectionBeats::compute) + .function("reset", &ChordsDetectionBeats::reset) + ; + + class_("ChromaCrossSimilarity") + .constructor() + .function("configure", &ChromaCrossSimilarity::configure) + .function("compute", &ChromaCrossSimilarity::compute) + .function("reset", &ChromaCrossSimilarity::reset) + ; + + class_("Chromagram") + .constructor() + .function("configure", &Chromagram::configure) + .function("compute", &Chromagram::compute) + .function("reset", &Chromagram::reset) + ; + + class_("ClickDetector") + .constructor() + .function("configure", &ClickDetector::configure) + .function("compute", &ClickDetector::compute) + .function("reset", &ClickDetector::reset) + ; + + class_("Clipper") + .constructor() + .function("configure", &Clipper::configure) + .function("compute", &Clipper::compute) + .function("reset", &Clipper::reset) + ; + + class_("CoverSongSimilarity") + .constructor() + .function("configure", &CoverSongSimilarity::configure) + .function("compute", &CoverSongSimilarity::compute) + .function("reset", &CoverSongSimilarity::reset) + ; + + class_("Crest") + .constructor<>() + .function("configure", &Crest::configure) + .function("compute", &Crest::compute) + .function("reset", &Crest::reset) + ; + + class_("CrossCorrelation") + .constructor() + .function("configure", &CrossCorrelation::configure) + .function("compute", &CrossCorrelation::compute) + .function("reset", &CrossCorrelation::reset) + ; + + class_("CrossSimilarityMatrix") + .constructor() + .function("configure", &CrossSimilarityMatrix::configure) + .function("compute", &CrossSimilarityMatrix::compute) + .function("reset", &CrossSimilarityMatrix::reset) + ; + + class_("CubicSpline") + .constructor&, std::vector&>() + .function("configure", &CubicSpline::configure) + .function("compute", &CubicSpline::compute) + .function("reset", &CubicSpline::reset) + ; + + class_("DCRemoval") + .constructor() + .function("configure", &DCRemoval::configure) + .function("compute", &DCRemoval::compute) + .function("reset", &DCRemoval::reset) + ; + + class_("DCT") + .constructor() + .function("configure", &DCT::configure) + .function("compute", &DCT::compute) + .function("reset", &DCT::reset) + ; + + class_("Danceability") + .constructor() + .function("configure", &Danceability::configure) + .function("compute", &Danceability::compute) + .function("reset", &Danceability::reset) + ; + + class_("Decrease") + .constructor() + .function("configure", &Decrease::configure) + .function("compute", &Decrease::compute) + .function("reset", &Decrease::reset) + ; + + class_("Derivative") + .constructor<>() + .function("configure", &Derivative::configure) + .function("compute", &Derivative::compute) + .function("reset", &Derivative::reset) + ; + + class_("DerivativeSFX") + .constructor<>() + .function("configure", &DerivativeSFX::configure) + .function("compute", &DerivativeSFX::compute) + .function("reset", &DerivativeSFX::reset) + ; + + class_("DiscontinuityDetector") + .constructor() + .function("configure", &DiscontinuityDetector::configure) + .function("compute", &DiscontinuityDetector::compute) + .function("reset", &DiscontinuityDetector::reset) + ; + + class_("Dissonance") + .constructor<>() + .function("configure", &Dissonance::configure) + .function("compute", &Dissonance::compute) + .function("reset", &Dissonance::reset) + ; + + class_("DistributionShape") + .constructor<>() + .function("configure", &DistributionShape::configure) + .function("compute", &DistributionShape::compute) + .function("reset", &DistributionShape::reset) + ; + + class_("Duration") + .constructor() + .function("configure", &Duration::configure) + .function("compute", &Duration::compute) + .function("reset", &Duration::reset) + ; + + class_("DynamicComplexity") + .constructor() + .function("configure", &DynamicComplexity::configure) + .function("compute", &DynamicComplexity::compute) + .function("reset", &DynamicComplexity::reset) + ; + + class_("ERBBands") + .constructor() + .function("configure", &ERBBands::configure) + .function("compute", &ERBBands::compute) + .function("reset", &ERBBands::reset) + ; + + class_("EffectiveDuration") + .constructor() + .function("configure", &EffectiveDuration::configure) + .function("compute", &EffectiveDuration::compute) + .function("reset", &EffectiveDuration::reset) + ; + + class_("Energy") + .constructor<>() + .function("configure", &Energy::configure) + .function("compute", &Energy::compute) + .function("reset", &Energy::reset) + ; + + class_("EnergyBand") + .constructor() + .function("configure", &EnergyBand::configure) + .function("compute", &EnergyBand::compute) + .function("reset", &EnergyBand::reset) + ; + + class_("EnergyBandRatio") + .constructor() + .function("configure", &EnergyBandRatio::configure) + .function("compute", &EnergyBandRatio::compute) + .function("reset", &EnergyBandRatio::reset) + ; + + class_("Entropy") + .constructor<>() + .function("configure", &Entropy::configure) + .function("compute", &Entropy::compute) + .function("reset", &Entropy::reset) + ; + + class_("Envelope") + .constructor() + .function("configure", &Envelope::configure) + .function("compute", &Envelope::compute) + .function("reset", &Envelope::reset) + ; + + class_("EqualLoudness") + .constructor() + .function("configure", &EqualLoudness::configure) + .function("compute", &EqualLoudness::compute) + .function("reset", &EqualLoudness::reset) + ; + + class_("Flatness") + .constructor<>() + .function("configure", &Flatness::configure) + .function("compute", &Flatness::compute) + .function("reset", &Flatness::reset) + ; + + class_("FlatnessDB") + .constructor<>() + .function("configure", &FlatnessDB::configure) + .function("compute", &FlatnessDB::compute) + .function("reset", &FlatnessDB::reset) + ; + + class_("FlatnessSFX") + .constructor<>() + .function("configure", &FlatnessSFX::configure) + .function("compute", &FlatnessSFX::compute) + .function("reset", &FlatnessSFX::reset) + ; + + class_("Flux") + .constructor() + .function("configure", &Flux::configure) + .function("compute", &Flux::compute) + .function("reset", &Flux::reset) + ; + + class_("FrameCutter") + .constructor() + .function("configure", &FrameCutter::configure) + .function("compute", &FrameCutter::compute) + .function("reset", &FrameCutter::reset) + ; + + class_("FrameToReal") + .constructor() + .function("configure", &FrameToReal::configure) + .function("compute", &FrameToReal::compute) + .function("reset", &FrameToReal::reset) + ; + + class_("FrequencyBands") + .constructor&, float>() + .function("configure", &FrequencyBands::configure) + .function("compute", &FrequencyBands::compute) + .function("reset", &FrequencyBands::reset) + ; + + class_("GFCC") + .constructor() + .function("configure", &GFCC::configure) + .function("compute", &GFCC::compute) + .function("reset", &GFCC::reset) + ; + + class_("GapsDetector") + .constructor() + .function("configure", &GapsDetector::configure) + .function("compute", &GapsDetector::compute) + .function("reset", &GapsDetector::reset) + ; + + class_("GeometricMean") + .constructor<>() + .function("configure", &GeometricMean::configure) + .function("compute", &GeometricMean::compute) + .function("reset", &GeometricMean::reset) + ; + + class_("HFC") + .constructor() + .function("configure", &HFC::configure) + .function("compute", &HFC::compute) + .function("reset", &HFC::reset) + ; + + class_("HPCP") + .constructor() + .function("configure", &HPCP::configure) + .function("compute", &HPCP::compute) + .function("reset", &HPCP::reset) + ; + + class_("HarmonicBpm") + .constructor() + .function("configure", &HarmonicBpm::configure) + .function("compute", &HarmonicBpm::compute) + .function("reset", &HarmonicBpm::reset) + ; + + class_("HarmonicPeaks") + .constructor() + .function("configure", &HarmonicPeaks::configure) + .function("compute", &HarmonicPeaks::compute) + .function("reset", &HarmonicPeaks::reset) + ; + + class_("HighPass") + .constructor() + .function("configure", &HighPass::configure) + .function("compute", &HighPass::compute) + .function("reset", &HighPass::reset) + ; + + class_("HighResolutionFeatures") + .constructor() + .function("configure", &HighResolutionFeatures::configure) + .function("compute", &HighResolutionFeatures::compute) + .function("reset", &HighResolutionFeatures::reset) + ; + + class_("Histogram") + .constructor() + .function("configure", &Histogram::configure) + .function("compute", &Histogram::compute) + .function("reset", &Histogram::reset) + ; + + class_("HprModelAnal") + .constructor() + .function("configure", &HprModelAnal::configure) + .function("compute", &HprModelAnal::compute) + .function("reset", &HprModelAnal::reset) + ; + + class_("HpsModelAnal") + .constructor() + .function("configure", &HpsModelAnal::configure) + .function("compute", &HpsModelAnal::compute) + .function("reset", &HpsModelAnal::reset) + ; + + class_("IDCT") + .constructor() + .function("configure", &IDCT::configure) + .function("compute", &IDCT::compute) + .function("reset", &IDCT::reset) + ; + + class_("IIR") + .constructor&, std::vector&>() + .function("configure", &IIR::configure) + .function("compute", &IIR::compute) + .function("reset", &IIR::reset) + ; + + class_("Inharmonicity") + .constructor<>() + .function("configure", &Inharmonicity::configure) + .function("compute", &Inharmonicity::compute) + .function("reset", &Inharmonicity::reset) + ; + + class_("InstantPower") + .constructor<>() + .function("configure", &InstantPower::configure) + .function("compute", &InstantPower::compute) + .function("reset", &InstantPower::reset) + ; + + class_("Intensity") + .constructor() + .function("configure", &Intensity::configure) + .function("compute", &Intensity::compute) + .function("reset", &Intensity::reset) + ; + + class_("Key") + .constructor() + .function("configure", &Key::configure) + .function("compute", &Key::compute) + .function("reset", &Key::reset) + ; + + class_("KeyExtractor") + .constructor() + .function("configure", &KeyExtractor::configure) + .function("compute", &KeyExtractor::compute) + .function("reset", &KeyExtractor::reset) + ; + + class_("LPC") + .constructor() + .function("configure", &LPC::configure) + .function("compute", &LPC::compute) + .function("reset", &LPC::reset) + ; + + class_("Larm") + .constructor() + .function("configure", &Larm::configure) + .function("compute", &Larm::compute) + .function("reset", &Larm::reset) + ; + + class_("Leq") + .constructor<>() + .function("configure", &Leq::configure) + .function("compute", &Leq::compute) + .function("reset", &Leq::reset) + ; + + class_("LevelExtractor") + .constructor() + .function("configure", &LevelExtractor::configure) + .function("compute", &LevelExtractor::compute) + .function("reset", &LevelExtractor::reset) + ; + + class_("LogAttackTime") + .constructor() + .function("configure", &LogAttackTime::configure) + .function("compute", &LogAttackTime::compute) + .function("reset", &LogAttackTime::reset) + ; + + class_("LogSpectrum") + .constructor() + .function("configure", &LogSpectrum::configure) + .function("compute", &LogSpectrum::compute) + .function("reset", &LogSpectrum::reset) + ; + + class_("LoopBpmConfidence") + .constructor() + .function("configure", &LoopBpmConfidence::configure) + .function("compute", &LoopBpmConfidence::compute) + .function("reset", &LoopBpmConfidence::reset) + ; + + class_("LoopBpmEstimator") + .constructor() + .function("configure", &LoopBpmEstimator::configure) + .function("compute", &LoopBpmEstimator::compute) + .function("reset", &LoopBpmEstimator::reset) + ; + + class_("Loudness") + .constructor<>() + .function("configure", &Loudness::configure) + .function("compute", &Loudness::compute) + .function("reset", &Loudness::reset) + ; + + class_("LoudnessVickers") + .constructor() + .function("configure", &LoudnessVickers::configure) + .function("compute", &LoudnessVickers::compute) + .function("reset", &LoudnessVickers::reset) + ; + + class_("LowLevelSpectralEqloudExtractor") + .constructor() + .function("configure", &LowLevelSpectralEqloudExtractor::configure) + .function("compute", &LowLevelSpectralEqloudExtractor::compute) + .function("reset", &LowLevelSpectralEqloudExtractor::reset) + ; + + class_("LowLevelSpectralExtractor") + .constructor() + .function("configure", &LowLevelSpectralExtractor::configure) + .function("compute", &LowLevelSpectralExtractor::compute) + .function("reset", &LowLevelSpectralExtractor::reset) + ; + + class_("LowPass") + .constructor() + .function("configure", &LowPass::configure) + .function("compute", &LowPass::compute) + .function("reset", &LowPass::reset) + ; + + class_("MFCC") + .constructor() + .function("configure", &MFCC::configure) + .function("compute", &MFCC::compute) + .function("reset", &MFCC::reset) + ; + + class_("MaxFilter") + .constructor() + .function("configure", &MaxFilter::configure) + .function("compute", &MaxFilter::compute) + .function("reset", &MaxFilter::reset) + ; + + class_("MaxMagFreq") + .constructor() + .function("configure", &MaxMagFreq::configure) + .function("compute", &MaxMagFreq::compute) + .function("reset", &MaxMagFreq::reset) + ; + + class_("MaxToTotal") + .constructor<>() + .function("configure", &MaxToTotal::configure) + .function("compute", &MaxToTotal::compute) + .function("reset", &MaxToTotal::reset) + ; + + class_("Mean") + .constructor<>() + .function("configure", &Mean::configure) + .function("compute", &Mean::compute) + .function("reset", &Mean::reset) + ; + + class_("Median") + .constructor<>() + .function("configure", &Median::configure) + .function("compute", &Median::compute) + .function("reset", &Median::reset) + ; + + class_("MedianFilter") + .constructor() + .function("configure", &MedianFilter::configure) + .function("compute", &MedianFilter::compute) + .function("reset", &MedianFilter::reset) + ; + + class_("MelBands") + .constructor() + .function("configure", &MelBands::configure) + .function("compute", &MelBands::compute) + .function("reset", &MelBands::reset) + ; + + class_("Meter") + .constructor<>() + .function("configure", &Meter::configure) + .function("compute", &Meter::compute) + .function("reset", &Meter::reset) + ; + + class_("MinMax") + .constructor() + .function("configure", &MinMax::configure) + .function("compute", &MinMax::compute) + .function("reset", &MinMax::reset) + ; + + class_("MinToTotal") + .constructor<>() + .function("configure", &MinToTotal::configure) + .function("compute", &MinToTotal::compute) + .function("reset", &MinToTotal::reset) + ; + + class_("MovingAverage") + .constructor() + .function("configure", &MovingAverage::configure) + .function("compute", &MovingAverage::compute) + .function("reset", &MovingAverage::reset) + ; + + class_("MultiPitchKlapuri") + .constructor() + .function("configure", &MultiPitchKlapuri::configure) + .function("compute", &MultiPitchKlapuri::compute) + .function("reset", &MultiPitchKlapuri::reset) + ; + + class_("MultiPitchMelodia") + .constructor() + .function("configure", &MultiPitchMelodia::configure) + .function("compute", &MultiPitchMelodia::compute) + .function("reset", &MultiPitchMelodia::reset) + ; + + class_("Multiplexer") + .constructor() + .function("configure", &Multiplexer::configure) + .function("compute", &Multiplexer::compute) + .function("reset", &Multiplexer::reset) + ; + + class_("NNLSChroma") + .constructor() + .function("configure", &NNLSChroma::configure) + .function("compute", &NNLSChroma::compute) + .function("reset", &NNLSChroma::reset) + ; + + class_("NoiseAdder") + .constructor() + .function("configure", &NoiseAdder::configure) + .function("compute", &NoiseAdder::compute) + .function("reset", &NoiseAdder::reset) + ; + + class_("NoiseBurstDetector") + .constructor() + .function("configure", &NoiseBurstDetector::configure) + .function("compute", &NoiseBurstDetector::compute) + .function("reset", &NoiseBurstDetector::reset) + ; + + class_("NoveltyCurve") + .constructor&, std::string>() + .function("configure", &NoveltyCurve::configure) + .function("compute", &NoveltyCurve::compute) + .function("reset", &NoveltyCurve::reset) + ; + + class_("NoveltyCurveFixedBpmEstimator") + .constructor() + .function("configure", &NoveltyCurveFixedBpmEstimator::configure) + .function("compute", &NoveltyCurveFixedBpmEstimator::compute) + .function("reset", &NoveltyCurveFixedBpmEstimator::reset) + ; + + class_("OddToEvenHarmonicEnergyRatio") + .constructor<>() + .function("configure", &OddToEvenHarmonicEnergyRatio::configure) + .function("compute", &OddToEvenHarmonicEnergyRatio::compute) + .function("reset", &OddToEvenHarmonicEnergyRatio::reset) + ; + + class_("OnsetDetection") + .constructor() + .function("configure", &OnsetDetection::configure) + .function("compute", &OnsetDetection::compute) + .function("reset", &OnsetDetection::reset) + ; + + class_("OnsetDetectionGlobal") + .constructor() + .function("configure", &OnsetDetectionGlobal::configure) + .function("compute", &OnsetDetectionGlobal::compute) + .function("reset", &OnsetDetectionGlobal::reset) + ; + + class_("OnsetRate") + .constructor<>() + .function("configure", &OnsetRate::configure) + .function("compute", &OnsetRate::compute) + .function("reset", &OnsetRate::reset) + ; + + class_("OverlapAdd") + .constructor() + .function("configure", &OverlapAdd::configure) + .function("compute", &OverlapAdd::compute) + .function("reset", &OverlapAdd::reset) + ; + + class_("PeakDetection") + .constructor() + .function("configure", &PeakDetection::configure) + .function("compute", &PeakDetection::compute) + .function("reset", &PeakDetection::reset) + ; + + class_("PercivalBpmEstimator") + .constructor() + .function("configure", &PercivalBpmEstimator::configure) + .function("compute", &PercivalBpmEstimator::compute) + .function("reset", &PercivalBpmEstimator::reset) + ; + + class_("PercivalEnhanceHarmonics") + .constructor<>() + .function("configure", &PercivalEnhanceHarmonics::configure) + .function("compute", &PercivalEnhanceHarmonics::compute) + .function("reset", &PercivalEnhanceHarmonics::reset) + ; + + class_("PercivalEvaluatePulseTrains") + .constructor<>() + .function("configure", &PercivalEvaluatePulseTrains::configure) + .function("compute", &PercivalEvaluatePulseTrains::compute) + .function("reset", &PercivalEvaluatePulseTrains::reset) + ; + + class_("PitchContourSegmentation") + .constructor() + .function("configure", &PitchContourSegmentation::configure) + .function("compute", &PitchContourSegmentation::compute) + .function("reset", &PitchContourSegmentation::reset) + ; + + class_("PitchContours") + .constructor() + .function("configure", &PitchContours::configure) + .function("compute", &PitchContours::compute) + .function("reset", &PitchContours::reset) + ; + + class_("PitchContoursMelody") + .constructor() + .function("configure", &PitchContoursMelody::configure) + .function("compute", &PitchContoursMelody::compute) + .function("reset", &PitchContoursMelody::reset) + ; + + class_("PitchContoursMonoMelody") + .constructor() + .function("configure", &PitchContoursMonoMelody::configure) + .function("compute", &PitchContoursMonoMelody::compute) + .function("reset", &PitchContoursMonoMelody::reset) + ; + + class_("PitchContoursMultiMelody") + .constructor() + .function("configure", &PitchContoursMultiMelody::configure) + .function("compute", &PitchContoursMultiMelody::compute) + .function("reset", &PitchContoursMultiMelody::reset) + ; + + class_("PitchFilter") + .constructor() + .function("configure", &PitchFilter::configure) + .function("compute", &PitchFilter::compute) + .function("reset", &PitchFilter::reset) + ; + + class_("PitchMelodia") + .constructor() + .function("configure", &PitchMelodia::configure) + .function("compute", &PitchMelodia::compute) + .function("reset", &PitchMelodia::reset) + ; + + class_("PitchSalience") + .constructor() + .function("configure", &PitchSalience::configure) + .function("compute", &PitchSalience::compute) + .function("reset", &PitchSalience::reset) + ; + + class_("PitchSalienceFunction") + .constructor() + .function("configure", &PitchSalienceFunction::configure) + .function("compute", &PitchSalienceFunction::compute) + .function("reset", &PitchSalienceFunction::reset) + ; + + class_("PitchSalienceFunctionPeaks") + .constructor() + .function("configure", &PitchSalienceFunctionPeaks::configure) + .function("compute", &PitchSalienceFunctionPeaks::compute) + .function("reset", &PitchSalienceFunctionPeaks::reset) + ; + + class_("PitchYin") + .constructor() + .function("configure", &PitchYin::configure) + .function("compute", &PitchYin::compute) + .function("reset", &PitchYin::reset) + ; + + class_("PitchYinFFT") + .constructor() + .function("configure", &PitchYinFFT::configure) + .function("compute", &PitchYinFFT::compute) + .function("reset", &PitchYinFFT::reset) + ; + + class_("PitchYinProbabilistic") + .constructor() + .function("configure", &PitchYinProbabilistic::configure) + .function("compute", &PitchYinProbabilistic::compute) + .function("reset", &PitchYinProbabilistic::reset) + ; + + class_("PitchYinProbabilities") + .constructor() + .function("configure", &PitchYinProbabilities::configure) + .function("compute", &PitchYinProbabilities::compute) + .function("reset", &PitchYinProbabilities::reset) + ; + + class_("PitchYinProbabilitiesHMM") + .constructor() + .function("configure", &PitchYinProbabilitiesHMM::configure) + .function("compute", &PitchYinProbabilitiesHMM::compute) + .function("reset", &PitchYinProbabilitiesHMM::reset) + ; + + class_("PowerMean") + .constructor() + .function("configure", &PowerMean::configure) + .function("compute", &PowerMean::compute) + .function("reset", &PowerMean::reset) + ; + + class_("PowerSpectrum") + .constructor() + .function("configure", &PowerSpectrum::configure) + .function("compute", &PowerSpectrum::compute) + .function("reset", &PowerSpectrum::reset) + ; + + class_("PredominantPitchMelodia") + .constructor() + .function("configure", &PredominantPitchMelodia::configure) + .function("compute", &PredominantPitchMelodia::compute) + .function("reset", &PredominantPitchMelodia::reset) + ; + + class_("RMS") + .constructor<>() + .function("configure", &RMS::configure) + .function("compute", &RMS::compute) + .function("reset", &RMS::reset) + ; + + class_("RawMoments") + .constructor() + .function("configure", &RawMoments::configure) + .function("compute", &RawMoments::compute) + .function("reset", &RawMoments::reset) + ; + + class_("ReplayGain") + .constructor() + .function("configure", &ReplayGain::configure) + .function("compute", &ReplayGain::compute) + .function("reset", &ReplayGain::reset) + ; + + class_("Resample") + .constructor() + .function("configure", &Resample::configure) + .function("compute", &Resample::compute) + .function("reset", &Resample::reset) + ; + + class_("ResampleFFT") + .constructor() + .function("configure", &ResampleFFT::configure) + .function("compute", &ResampleFFT::compute) + .function("reset", &ResampleFFT::reset) + ; + + class_("RhythmDescriptors") + .constructor<>() + .function("configure", &RhythmDescriptors::configure) + .function("compute", &RhythmDescriptors::compute) + .function("reset", &RhythmDescriptors::reset) + ; + + class_("RhythmExtractor") + .constructor&, float, bool, bool>() + .function("configure", &RhythmExtractor::configure) + .function("compute", &RhythmExtractor::compute) + .function("reset", &RhythmExtractor::reset) + ; + + class_("RhythmExtractor2013") + .constructor() + .function("configure", &RhythmExtractor2013::configure) + .function("compute", &RhythmExtractor2013::compute) + .function("reset", &RhythmExtractor2013::reset) + ; + + class_("RhythmTransform") + .constructor() + .function("configure", &RhythmTransform::configure) + .function("compute", &RhythmTransform::compute) + .function("reset", &RhythmTransform::reset) + ; + + class_("RollOff") + .constructor() + .function("configure", &RollOff::configure) + .function("compute", &RollOff::compute) + .function("reset", &RollOff::reset) + ; + + class_("SNR") + .constructor() + .function("configure", &SNR::configure) + .function("compute", &SNR::compute) + .function("reset", &SNR::reset) + ; + + class_("SaturationDetector") + .constructor() + .function("configure", &SaturationDetector::configure) + .function("compute", &SaturationDetector::compute) + .function("reset", &SaturationDetector::reset) + ; + + class_("Scale") + .constructor() + .function("configure", &Scale::configure) + .function("compute", &Scale::compute) + .function("reset", &Scale::reset) + ; + + class_("SineSubtraction") + .constructor() + .function("configure", &SineSubtraction::configure) + .function("compute", &SineSubtraction::compute) + .function("reset", &SineSubtraction::reset) + ; + + class_("SingleBeatLoudness") + .constructor&, std::string, float>() + .function("configure", &SingleBeatLoudness::configure) + .function("compute", &SingleBeatLoudness::compute) + .function("reset", &SingleBeatLoudness::reset) + ; + + class_("Slicer") + .constructor&, float, std::vector&, std::string>() + .function("configure", &Slicer::configure) + .function("compute", &Slicer::compute) + .function("reset", &Slicer::reset) + ; + + class_("SpectralCentroidTime") + .constructor() + .function("configure", &SpectralCentroidTime::configure) + .function("compute", &SpectralCentroidTime::compute) + .function("reset", &SpectralCentroidTime::reset) + ; + + class_("SpectralComplexity") + .constructor() + .function("configure", &SpectralComplexity::configure) + .function("compute", &SpectralComplexity::compute) + .function("reset", &SpectralComplexity::reset) + ; + + class_("SpectralContrast") + .constructor() + .function("configure", &SpectralContrast::configure) + .function("compute", &SpectralContrast::compute) + .function("reset", &SpectralContrast::reset) + ; + + class_("SpectralPeaks") + .constructor() + .function("configure", &SpectralPeaks::configure) + .function("compute", &SpectralPeaks::compute) + .function("reset", &SpectralPeaks::reset) + ; + + class_("SpectralWhitening") + .constructor() + .function("configure", &SpectralWhitening::configure) + .function("compute", &SpectralWhitening::compute) + .function("reset", &SpectralWhitening::reset) + ; + + class_("Spectrum") + .constructor() + .function("configure", &Spectrum::configure) + .function("compute", &Spectrum::compute) + .function("reset", &Spectrum::reset) + ; + + class_("SpectrumCQ") + .constructor() + .function("configure", &SpectrumCQ::configure) + .function("compute", &SpectrumCQ::compute) + .function("reset", &SpectrumCQ::reset) + ; + + class_("SpectrumToCent") + .constructor() + .function("configure", &SpectrumToCent::configure) + .function("compute", &SpectrumToCent::compute) + .function("reset", &SpectrumToCent::reset) + ; + + class_("Spline") + .constructor&, std::vector&>() + .function("configure", &Spline::configure) + .function("compute", &Spline::compute) + .function("reset", &Spline::reset) + ; + + class_("SprModelAnal") + .constructor() + .function("configure", &SprModelAnal::configure) + .function("compute", &SprModelAnal::compute) + .function("reset", &SprModelAnal::reset) + ; + + class_("SprModelSynth") + .constructor() + .function("configure", &SprModelSynth::configure) + .function("compute", &SprModelSynth::compute) + .function("reset", &SprModelSynth::reset) + ; + + class_("SpsModelAnal") + .constructor() + .function("configure", &SpsModelAnal::configure) + .function("compute", &SpsModelAnal::compute) + .function("reset", &SpsModelAnal::reset) + ; + + class_("SpsModelSynth") + .constructor() + .function("configure", &SpsModelSynth::configure) + .function("compute", &SpsModelSynth::compute) + .function("reset", &SpsModelSynth::reset) + ; + + class_("StartStopCut") + .constructor() + .function("configure", &StartStopCut::configure) + .function("compute", &StartStopCut::compute) + .function("reset", &StartStopCut::reset) + ; + + class_("StartStopSilence") + .constructor() + .function("configure", &StartStopSilence::configure) + .function("compute", &StartStopSilence::compute) + .function("reset", &StartStopSilence::reset) + ; + + class_("StochasticModelAnal") + .constructor() + .function("configure", &StochasticModelAnal::configure) + .function("compute", &StochasticModelAnal::compute) + .function("reset", &StochasticModelAnal::reset) + ; + + class_("StochasticModelSynth") + .constructor() + .function("configure", &StochasticModelSynth::configure) + .function("compute", &StochasticModelSynth::compute) + .function("reset", &StochasticModelSynth::reset) + ; + + class_("StrongDecay") + .constructor() + .function("configure", &StrongDecay::configure) + .function("compute", &StrongDecay::compute) + .function("reset", &StrongDecay::reset) + ; + + class_("StrongPeak") + .constructor<>() + .function("configure", &StrongPeak::configure) + .function("compute", &StrongPeak::compute) + .function("reset", &StrongPeak::reset) + ; + + class_("SuperFluxExtractor") + .constructor() + .function("configure", &SuperFluxExtractor::configure) + .function("compute", &SuperFluxExtractor::compute) + .function("reset", &SuperFluxExtractor::reset) + ; + + class_("SuperFluxNovelty") + .constructor() + .function("configure", &SuperFluxNovelty::configure) + .function("compute", &SuperFluxNovelty::compute) + .function("reset", &SuperFluxNovelty::reset) + ; + + class_("SuperFluxPeaks") + .constructor() + .function("configure", &SuperFluxPeaks::configure) + .function("compute", &SuperFluxPeaks::compute) + .function("reset", &SuperFluxPeaks::reset) + ; + + class_("TCToTotal") + .constructor<>() + .function("configure", &TCToTotal::configure) + .function("compute", &TCToTotal::compute) + .function("reset", &TCToTotal::reset) + ; + + class_("TempoScaleBands") + .constructor&, float>() + .function("configure", &TempoScaleBands::configure) + .function("compute", &TempoScaleBands::compute) + .function("reset", &TempoScaleBands::reset) + ; + + class_("TempoTap") + .constructor&>() + .function("configure", &TempoTap::configure) + .function("compute", &TempoTap::compute) + .function("reset", &TempoTap::reset) + ; + + class_("TempoTapDegara") + .constructor() + .function("configure", &TempoTapDegara::configure) + .function("compute", &TempoTapDegara::compute) + .function("reset", &TempoTapDegara::reset) + ; + + class_("TempoTapMaxAgreement") + .constructor<>() + .function("configure", &TempoTapMaxAgreement::configure) + .function("compute", &TempoTapMaxAgreement::compute) + .function("reset", &TempoTapMaxAgreement::reset) + ; + + class_("TempoTapTicks") + .constructor() + .function("configure", &TempoTapTicks::configure) + .function("compute", &TempoTapTicks::compute) + .function("reset", &TempoTapTicks::reset) + ; + + class_("TensorflowInputFSDSINet") + .constructor<>() + .function("configure", &TensorflowInputFSDSINet::configure) + .function("compute", &TensorflowInputFSDSINet::compute) + .function("reset", &TensorflowInputFSDSINet::reset) + ; + + class_("TensorflowInputMusiCNN") + .constructor<>() + .function("configure", &TensorflowInputMusiCNN::configure) + .function("compute", &TensorflowInputMusiCNN::compute) + .function("reset", &TensorflowInputMusiCNN::reset) + ; + + class_("TensorflowInputTempoCNN") + .constructor<>() + .function("configure", &TensorflowInputTempoCNN::configure) + .function("compute", &TensorflowInputTempoCNN::compute) + .function("reset", &TensorflowInputTempoCNN::reset) + ; + + class_("TensorflowInputVGGish") + .constructor<>() + .function("configure", &TensorflowInputVGGish::configure) + .function("compute", &TensorflowInputVGGish::compute) + .function("reset", &TensorflowInputVGGish::reset) + ; + + class_("TonalExtractor") + .constructor() + .function("configure", &TonalExtractor::configure) + .function("compute", &TonalExtractor::compute) + .function("reset", &TonalExtractor::reset) + ; + + class_("TonicIndianArtMusic") + .constructor() + .function("configure", &TonicIndianArtMusic::configure) + .function("compute", &TonicIndianArtMusic::compute) + .function("reset", &TonicIndianArtMusic::reset) + ; + + class_("TriangularBands") + .constructor&, int, bool, std::string, float, std::string, std::string>() + .function("configure", &TriangularBands::configure) + .function("compute", &TriangularBands::compute) + .function("reset", &TriangularBands::reset) + ; + + class_("TriangularBarkBands") + .constructor() + .function("configure", &TriangularBarkBands::configure) + .function("compute", &TriangularBarkBands::compute) + .function("reset", &TriangularBarkBands::reset) + ; + + class_("Trimmer") + .constructor() + .function("configure", &Trimmer::configure) + .function("compute", &Trimmer::compute) + .function("reset", &Trimmer::reset) + ; + + class_("Tristimulus") + .constructor<>() + .function("configure", &Tristimulus::configure) + .function("compute", &Tristimulus::compute) + .function("reset", &Tristimulus::reset) + ; + + class_("TruePeakDetector") + .constructor() + .function("configure", &TruePeakDetector::configure) + .function("compute", &TruePeakDetector::compute) + .function("reset", &TruePeakDetector::reset) + ; + + class_("TuningFrequency") + .constructor() + .function("configure", &TuningFrequency::configure) + .function("compute", &TuningFrequency::compute) + .function("reset", &TuningFrequency::reset) + ; + + class_("TuningFrequencyExtractor") + .constructor() + .function("configure", &TuningFrequencyExtractor::configure) + .function("compute", &TuningFrequencyExtractor::compute) + .function("reset", &TuningFrequencyExtractor::reset) + ; + + class_("UnaryOperator") + .constructor() + .function("configure", &UnaryOperator::configure) + .function("compute", &UnaryOperator::compute) + .function("reset", &UnaryOperator::reset) + ; + + class_("UnaryOperatorStream") + .constructor() + .function("configure", &UnaryOperatorStream::configure) + .function("compute", &UnaryOperatorStream::compute) + .function("reset", &UnaryOperatorStream::reset) + ; + + class_("Variance") + .constructor<>() + .function("configure", &Variance::configure) + .function("compute", &Variance::compute) + .function("reset", &Variance::reset) + ; + + class_("Vibrato") + .constructor() + .function("configure", &Vibrato::configure) + .function("compute", &Vibrato::compute) + .function("reset", &Vibrato::reset) + ; + + class_("WarpedAutoCorrelation") + .constructor() + .function("configure", &WarpedAutoCorrelation::configure) + .function("compute", &WarpedAutoCorrelation::compute) + .function("reset", &WarpedAutoCorrelation::reset) + ; + + class_("Welch") + .constructor() + .function("configure", &Welch::configure) + .function("compute", &Welch::compute) + .function("reset", &Welch::reset) + ; + + class_("Windowing") + .constructor() + .function("configure", &Windowing::configure) + .function("compute", &Windowing::compute) + .function("reset", &Windowing::reset) + ; + + class_("ZeroCrossingRate") + .constructor() + .function("configure", &ZeroCrossingRate::configure) + .function("compute", &ZeroCrossingRate::compute) + .function("reset", &ZeroCrossingRate::reset) + ; // utility function to convert a Float32 JS typed array into std::vector function("arrayToVector", &float32ArrayToVector); // expose stl datatypes to js diff --git a/src/cpp/includes/essentiajs.h b/src/cpp/includes/essentiajs.h index 9069135..b8ff3b8 100644 --- a/src/cpp/includes/essentiajs.h +++ b/src/cpp/includes/essentiajs.h @@ -22,7 +22,6 @@ #ifndef ESSENTIAJS_H #define ESSENTIAJS_H -#include #include #include #include diff --git a/src/python/bindings.cog b/src/python/bindings.cog index 4a04044..1175f04 100644 --- a/src/python/bindings.cog +++ b/src/python/bindings.cog @@ -18,31 +18,28 @@ */ // NOTE: This source code is auto-generated. - +#include #include "./includes/essentiajs.h" // expose essentiajs class to js using embind wrappers -EMSCRIPTEN_BINDINGS(CLASS_EssentiaJS) { +EMSCRIPTEN_BINDINGS(CLASS_EssentiaJS) { + function("bootEssentia", &bootEssentia); + class_("FrameGenerator") + .constructor() + .function("configure", &FrameGenerator::configure) + .function("compute", &FrameGenerator::compute) + .function("reset", &FrameGenerator::reset) + ; // NOTE: The following code snippets are machine generated. Do not edit. - class_("EssentiaJS") - .constructor() - .property("version", &EssentiaJS::essentiaVersion) - .property("algorithmNames", &EssentiaJS::algorithmNames) - .function("shutdown", &EssentiaJS::shutdown) - .function("FrameGenerator", &EssentiaJS::FrameGenerator) - .function("MonoMixer", &EssentiaJS::MonoMixer) - .function("LoudnessEBUR128", &EssentiaJS::LoudnessEBUR128) - /*[[[cog - import logging - import cog - from code_generator import TO_INCLUDE_ALGOS - logging.basicConfig(level='INFO') - logging.info("Generating emscripten bindings for the essentia...") - for algo_name in TO_INCLUDE_ALGOS: - cog.outl('.function("%s", &EssentiaJS::%s)' % (algo_name, algo_name)) - cog.out(";") - ]]]*/ - //[[[end]]] + /*[[[cog + import cog + from code_generator import generate_bindings + + bindings = generate_bindings() + for ln in bindings: + cog.outl(ln) + ]]]*/ + //[[[end]]] // utility function to convert a Float32 JS typed array into std::vector function("arrayToVector", &float32ArrayToVector); // expose stl datatypes to js diff --git a/src/python/code_generator.py b/src/python/code_generator.py index 3d39005..e2d59ed 100644 --- a/src/python/code_generator.py +++ b/src/python/code_generator.py @@ -83,6 +83,7 @@ def parse_algorithm_info(algorithm_name, target="header"): param_dict['params'] = [] output_var_names = list() param_var_names = list() + param_type_list = list() # create the algorithm object algo = getattr(estd, algorithm_name)() doc_dict = algo.getStruct() @@ -94,28 +95,32 @@ def parse_algorithm_info(algorithm_name, target="header"): inputs.append(input_var) # parse parameters - for params in doc_dict['parameters']: - if params['type'] == 'string': + for param in doc_dict['parameters']: + param_type = map_types_to_cpp(param['type']) + param_type_list.append(param_type) + if target == "binding": + continue + if param['type'] == 'string': if target == 'header': - parameters.append('const %s& %s="%s"' % (map_types_to_cpp(params['type']), - params['name'], - params['default'])) + parameters.append('const %s& %s="%s"' % (param_type, + param['name'], + param['default'])) elif target == "algorithm": - parameters.append('const %s& %s' % (map_types_to_cpp(params['type']), - params['name'])) - elif params['type'] == 'vector_real': - parameters.append(map_vector_params_to_cpp(params, target=target)) + parameters.append('const %s& %s' % (param_type, + param['name'])) + elif param['type'] == 'vector_real': + parameters.append(map_vector_params_to_cpp(param, target=target)) else: if target == 'header': - parameters.append("const %s %s=%s" % (map_types_to_cpp(params['type']), - params['name'], - params['default'])) + parameters.append("const %s %s=%s" % (param_type, + param['name'], + param['default'])) elif target == 'algorithm': - parameters.append("const %s %s" % (map_types_to_cpp(params['type']), - params['name'])) + parameters.append("const %s %s" % (param_type, + param['name'])) - param_dict['params'].append('"%s", %s' % (params['name'], params['name'])) - param_var_names.append(params['name']) + param_dict['params'].append('"%s", %s' % (param['name'], param['name'])) + param_var_names.append(param['name']) # parse outputs # if the algorithm has multiple outputs we construct a void function, otherwise return it's return type @@ -220,6 +225,16 @@ def close_def_body(): return algorithm + elif target == "binding": + binding_str = f""" +class_<{algorithm_name}>("{algorithm_name}") + .constructor<{', '.join(param_type_list)}>() + .function("configure", &{algorithm_name}::configure) + .function("compute", &{algorithm_name}::compute) + .function("reset", &{algorithm_name}::reset) + ;""" + return binding_str + else: raise IOError(f"Given target={target} is not valid. 'target' should be either 'header' or 'algorithm'.") @@ -249,6 +264,12 @@ def generate_algorithms(algorithms=TO_INCLUDE_ALGOS): logging.info("Finished generating cpp source code for %s essentia algorithms" % (len(algorithms) + 3)) return algos +def generate_bindings(algorithms=TO_INCLUDE_ALGOS): + logging.info("Generating emscripten bindings for the essentia...") + bindings = list() + for algo_name in algorithms: + bindings.append(parse_algorithm_info(algo_name, target="binding")) + return bindings def map_types_to_js(es_type): if es_type in ['vector_real', diff --git a/src/python/header.cog b/src/python/header.cog index 09152bc..bd7fe88 100644 --- a/src/python/header.cog +++ b/src/python/header.cog @@ -22,7 +22,6 @@ #ifndef ESSENTIAJS_H #define ESSENTIAJS_H -#include #include #include #include From 8a66bf617a407e036c8c198a5b24481a16078fd6 Mon Sep 17 00:00:00 2001 From: Jorge Marcos Date: Fri, 16 Feb 2024 00:32:43 +0100 Subject: [PATCH 04/18] fix cog files, successful compilation --- src/cpp/bindings_essentiajs.cpp | 4 ++-- src/cpp/includes/essentiajs.cpp | 3 +++ src/cpp/includes/essentiajs.h | 5 +++-- src/python/bindings.cog | 3 ++- src/python/header.cog | 5 +++-- src/python/library.cog | 3 +++ 6 files changed, 16 insertions(+), 7 deletions(-) diff --git a/src/cpp/bindings_essentiajs.cpp b/src/cpp/bindings_essentiajs.cpp index b3abb3a..c3ee22d 100644 --- a/src/cpp/bindings_essentiajs.cpp +++ b/src/cpp/bindings_essentiajs.cpp @@ -23,13 +23,13 @@ // expose essentiajs class to js using embind wrappers EMSCRIPTEN_BINDINGS(CLASS_EssentiaJS) { - function("bootEssentia", &bootEssentia); + function("init", &_initEssentia); + constant("algorithmNames", ALGORITHM_NAMES); class_("FrameGenerator") .constructor() .function("configure", &FrameGenerator::configure) .function("compute", &FrameGenerator::compute) .function("reset", &FrameGenerator::reset) - .function("shutdown", &FrameGenerator::shutdown) ; // NOTE: The following code snippets are machine generated. Do not edit. diff --git a/src/cpp/includes/essentiajs.cpp b/src/cpp/includes/essentiajs.cpp index 495be48..cb4d9ba 100644 --- a/src/cpp/includes/essentiajs.cpp +++ b/src/cpp/includes/essentiajs.cpp @@ -37,6 +37,9 @@ std::vector float32ArrayToVector(const val &arr) { return vec; } +void _initEssentia() { + essentia::init(); +} // START FrameGenerator definitions FrameGenerator::FrameGenerator(int frameSize, int hopSize) { diff --git a/src/cpp/includes/essentiajs.h b/src/cpp/includes/essentiajs.h index b8ff3b8..cea05c4 100644 --- a/src/cpp/includes/essentiajs.h +++ b/src/cpp/includes/essentiajs.h @@ -25,12 +25,13 @@ #include #include #include +#include using namespace essentia; using namespace essentia::standard; using namespace emscripten; -void init(); +void _initEssentia(); // method for generating frames from a given audio signal class FrameGenerator { @@ -49,7 +50,7 @@ class FrameGenerator { // NOTE: The following code snippets are machine generated. Do not edit. // class property which stores all the list of essentia algorithm names available in essentia.js -std::string algorithmNames = "['AfterMaxToBeforeMaxEnergyRatio', 'AllPass', 'AudioOnsetsMarker', 'AutoCorrelation', 'BFCC', 'BPF', 'BandPass', 'BandReject', 'BarkBands', 'BeatTrackerDegara', 'BeatTrackerMultiFeature', 'Beatogram', 'BeatsLoudness', 'BinaryOperator', 'BinaryOperatorStream', 'BpmHistogramDescriptors', 'BpmRubato', 'CentralMoments', 'Centroid', 'ChordsDescriptors', 'ChordsDetection', 'ChordsDetectionBeats', 'ChromaCrossSimilarity', 'Chromagram', 'ClickDetector', 'Clipper', 'CoverSongSimilarity', 'Crest', 'CrossCorrelation', 'CrossSimilarityMatrix', 'CubicSpline', 'DCRemoval', 'DCT', 'Danceability', 'Decrease', 'Derivative', 'DerivativeSFX', 'DiscontinuityDetector', 'Dissonance', 'DistributionShape', 'Duration', 'DynamicComplexity', 'ERBBands', 'EffectiveDuration', 'Energy', 'EnergyBand', 'EnergyBandRatio', 'Entropy', 'Envelope', 'EqualLoudness', 'Flatness', 'FlatnessDB', 'FlatnessSFX', 'Flux', 'FrameCutter', 'FrameToReal', 'FrequencyBands', 'GFCC', 'GapsDetector', 'GeometricMean', 'HFC', 'HPCP', 'HarmonicBpm', 'HarmonicPeaks', 'HighPass', 'HighResolutionFeatures', 'Histogram', 'HprModelAnal', 'HpsModelAnal', 'IDCT', 'IIR', 'Inharmonicity', 'InstantPower', 'Intensity', 'Key', 'KeyExtractor', 'LPC', 'Larm', 'Leq', 'LevelExtractor', 'LogAttackTime', 'LogSpectrum', 'LoopBpmConfidence', 'LoopBpmEstimator', 'Loudness', 'LoudnessVickers', 'LowLevelSpectralEqloudExtractor', 'LowLevelSpectralExtractor', 'LowPass', 'MFCC', 'MaxFilter', 'MaxMagFreq', 'MaxToTotal', 'Mean', 'Median', 'MedianFilter', 'MelBands', 'Meter', 'MinMax', 'MinToTotal', 'MovingAverage', 'MultiPitchKlapuri', 'MultiPitchMelodia', 'Multiplexer', 'NNLSChroma', 'NoiseAdder', 'NoiseBurstDetector', 'NoveltyCurve', 'NoveltyCurveFixedBpmEstimator', 'OddToEvenHarmonicEnergyRatio', 'OnsetDetection', 'OnsetDetectionGlobal', 'OnsetRate', 'OverlapAdd', 'PeakDetection', 'PercivalBpmEstimator', 'PercivalEnhanceHarmonics', 'PercivalEvaluatePulseTrains', 'PitchContourSegmentation', 'PitchContours', 'PitchContoursMelody', 'PitchContoursMonoMelody', 'PitchContoursMultiMelody', 'PitchFilter', 'PitchMelodia', 'PitchSalience', 'PitchSalienceFunction', 'PitchSalienceFunctionPeaks', 'PitchYin', 'PitchYinFFT', 'PitchYinProbabilistic', 'PitchYinProbabilities', 'PitchYinProbabilitiesHMM', 'PowerMean', 'PowerSpectrum', 'PredominantPitchMelodia', 'RMS', 'RawMoments', 'ReplayGain', 'Resample', 'ResampleFFT', 'RhythmDescriptors', 'RhythmExtractor', 'RhythmExtractor2013', 'RhythmTransform', 'RollOff', 'SNR', 'SaturationDetector', 'Scale', 'SineSubtraction', 'SingleBeatLoudness', 'Slicer', 'SpectralCentroidTime', 'SpectralComplexity', 'SpectralContrast', 'SpectralPeaks', 'SpectralWhitening', 'Spectrum', 'SpectrumCQ', 'SpectrumToCent', 'Spline', 'SprModelAnal', 'SprModelSynth', 'SpsModelAnal', 'SpsModelSynth', 'StartStopCut', 'StartStopSilence', 'StochasticModelAnal', 'StochasticModelSynth', 'StrongDecay', 'StrongPeak', 'SuperFluxExtractor', 'SuperFluxNovelty', 'SuperFluxPeaks', 'TCToTotal', 'TempoScaleBands', 'TempoTap', 'TempoTapDegara', 'TempoTapMaxAgreement', 'TempoTapTicks', 'TensorflowInputFSDSINet', 'TensorflowInputMusiCNN', 'TensorflowInputTempoCNN', 'TensorflowInputVGGish', 'TonalExtractor', 'TonicIndianArtMusic', 'TriangularBands', 'TriangularBarkBands', 'Trimmer', 'Tristimulus', 'TruePeakDetector', 'TuningFrequency', 'TuningFrequencyExtractor', 'UnaryOperator', 'UnaryOperatorStream', 'Variance', 'Vibrato', 'WarpedAutoCorrelation', 'Welch', 'Windowing', 'ZeroCrossingRate']"; +const std::string ALGORITHM_NAMES = "['AfterMaxToBeforeMaxEnergyRatio', 'AllPass', 'AudioOnsetsMarker', 'AutoCorrelation', 'BFCC', 'BPF', 'BandPass', 'BandReject', 'BarkBands', 'BeatTrackerDegara', 'BeatTrackerMultiFeature', 'Beatogram', 'BeatsLoudness', 'BinaryOperator', 'BinaryOperatorStream', 'BpmHistogramDescriptors', 'BpmRubato', 'CentralMoments', 'Centroid', 'ChordsDescriptors', 'ChordsDetection', 'ChordsDetectionBeats', 'ChromaCrossSimilarity', 'Chromagram', 'ClickDetector', 'Clipper', 'CoverSongSimilarity', 'Crest', 'CrossCorrelation', 'CrossSimilarityMatrix', 'CubicSpline', 'DCRemoval', 'DCT', 'Danceability', 'Decrease', 'Derivative', 'DerivativeSFX', 'DiscontinuityDetector', 'Dissonance', 'DistributionShape', 'Duration', 'DynamicComplexity', 'ERBBands', 'EffectiveDuration', 'Energy', 'EnergyBand', 'EnergyBandRatio', 'Entropy', 'Envelope', 'EqualLoudness', 'Flatness', 'FlatnessDB', 'FlatnessSFX', 'Flux', 'FrameCutter', 'FrameToReal', 'FrequencyBands', 'GFCC', 'GapsDetector', 'GeometricMean', 'HFC', 'HPCP', 'HarmonicBpm', 'HarmonicPeaks', 'HighPass', 'HighResolutionFeatures', 'Histogram', 'HprModelAnal', 'HpsModelAnal', 'IDCT', 'IIR', 'Inharmonicity', 'InstantPower', 'Intensity', 'Key', 'KeyExtractor', 'LPC', 'Larm', 'Leq', 'LevelExtractor', 'LogAttackTime', 'LogSpectrum', 'LoopBpmConfidence', 'LoopBpmEstimator', 'Loudness', 'LoudnessVickers', 'LowLevelSpectralEqloudExtractor', 'LowLevelSpectralExtractor', 'LowPass', 'MFCC', 'MaxFilter', 'MaxMagFreq', 'MaxToTotal', 'Mean', 'Median', 'MedianFilter', 'MelBands', 'Meter', 'MinMax', 'MinToTotal', 'MovingAverage', 'MultiPitchKlapuri', 'MultiPitchMelodia', 'Multiplexer', 'NNLSChroma', 'NoiseAdder', 'NoiseBurstDetector', 'NoveltyCurve', 'NoveltyCurveFixedBpmEstimator', 'OddToEvenHarmonicEnergyRatio', 'OnsetDetection', 'OnsetDetectionGlobal', 'OnsetRate', 'OverlapAdd', 'PeakDetection', 'PercivalBpmEstimator', 'PercivalEnhanceHarmonics', 'PercivalEvaluatePulseTrains', 'PitchContourSegmentation', 'PitchContours', 'PitchContoursMelody', 'PitchContoursMonoMelody', 'PitchContoursMultiMelody', 'PitchFilter', 'PitchMelodia', 'PitchSalience', 'PitchSalienceFunction', 'PitchSalienceFunctionPeaks', 'PitchYin', 'PitchYinFFT', 'PitchYinProbabilistic', 'PitchYinProbabilities', 'PitchYinProbabilitiesHMM', 'PowerMean', 'PowerSpectrum', 'PredominantPitchMelodia', 'RMS', 'RawMoments', 'ReplayGain', 'Resample', 'ResampleFFT', 'RhythmDescriptors', 'RhythmExtractor', 'RhythmExtractor2013', 'RhythmTransform', 'RollOff', 'SNR', 'SaturationDetector', 'Scale', 'SineSubtraction', 'SingleBeatLoudness', 'Slicer', 'SpectralCentroidTime', 'SpectralComplexity', 'SpectralContrast', 'SpectralPeaks', 'SpectralWhitening', 'Spectrum', 'SpectrumCQ', 'SpectrumToCent', 'Spline', 'SprModelAnal', 'SprModelSynth', 'SpsModelAnal', 'SpsModelSynth', 'StartStopCut', 'StartStopSilence', 'StochasticModelAnal', 'StochasticModelSynth', 'StrongDecay', 'StrongPeak', 'SuperFluxExtractor', 'SuperFluxNovelty', 'SuperFluxPeaks', 'TCToTotal', 'TempoScaleBands', 'TempoTap', 'TempoTapDegara', 'TempoTapMaxAgreement', 'TempoTapTicks', 'TensorflowInputFSDSINet', 'TensorflowInputMusiCNN', 'TensorflowInputTempoCNN', 'TensorflowInputVGGish', 'TonalExtractor', 'TonicIndianArtMusic', 'TriangularBands', 'TriangularBarkBands', 'Trimmer', 'Tristimulus', 'TruePeakDetector', 'TuningFrequency', 'TuningFrequencyExtractor', 'UnaryOperator', 'UnaryOperatorStream', 'Variance', 'Vibrato', 'WarpedAutoCorrelation', 'Welch', 'Windowing', 'ZeroCrossingRate']"; // class methods to call various essentia algorithms class AfterMaxToBeforeMaxEnergyRatio { diff --git a/src/python/bindings.cog b/src/python/bindings.cog index 1175f04..11189df 100644 --- a/src/python/bindings.cog +++ b/src/python/bindings.cog @@ -23,7 +23,8 @@ // expose essentiajs class to js using embind wrappers EMSCRIPTEN_BINDINGS(CLASS_EssentiaJS) { - function("bootEssentia", &bootEssentia); + function("init", &_initEssentia); + constant("algorithmNames", ALGORITHM_NAMES); class_("FrameGenerator") .constructor() .function("configure", &FrameGenerator::configure) diff --git a/src/python/header.cog b/src/python/header.cog index bd7fe88..88b7502 100644 --- a/src/python/header.cog +++ b/src/python/header.cog @@ -25,12 +25,13 @@ #include #include #include +#include using namespace essentia; using namespace essentia::standard; using namespace emscripten; -void init(); +void _initEssentia(); // method for generating frames from a given audio signal class FrameGenerator { @@ -53,7 +54,7 @@ from code_generator import generate_headers, TO_INCLUDE_ALGOS cog.outl(" ") cog.outl("// class property which stores all the list of essentia algorithm names available in essentia.js") c_algo_list = str(TO_INCLUDE_ALGOS) -cog.outl(f'std::string algorithmNames = "{c_algo_list}";') +cog.outl(f'const std::string ALGORITHM_NAMES = "{c_algo_list}";') cog.outl("// class methods to call various essentia algorithms") headers = generate_headers() for ln in headers: diff --git a/src/python/library.cog b/src/python/library.cog index 8a2c7c2..1a8758b 100644 --- a/src/python/library.cog +++ b/src/python/library.cog @@ -37,6 +37,9 @@ std::vector float32ArrayToVector(const val &arr) { return vec; } +void _initEssentia() { + essentia::init(); +} // START FrameGenerator definitions FrameGenerator::FrameGenerator(int frameSize, int hopSize) { From 31bf822124d3d2b0e8103174de2170f84b4dc78e Mon Sep 17 00:00:00 2001 From: Jorge Marcos Date: Mon, 19 Feb 2024 11:40:42 +0100 Subject: [PATCH 05/18] use py3 f-strings on parse_to_typescript --- src/python/code_generator.py | 104 ++++++++++++-------------------- src/typescript/core_api.ts | 114 +++++++++++++++++++++-------------- 2 files changed, 106 insertions(+), 112 deletions(-) diff --git a/src/python/code_generator.py b/src/python/code_generator.py index e2d59ed..f7c1b14 100644 --- a/src/python/code_generator.py +++ b/src/python/code_generator.py @@ -323,111 +323,81 @@ def parse_to_typescript(algorithm_name): 'vector_vector_complex', 'vector_stereosample']: - inputs.append("%s: any" % inp['name']) + inputs.append(f"{inp['name']}: any") if inp['type'] in ['vector_real', 'vector_complex', 'matrix_real']: - comments.append("%s {VectorFloat} %s %s" % (param_prefix, - inp['name'], - inp['description'])) + comment_input_type = "{VectorFloat}" elif inp['type'] == "vector_string": - comments.append("%s {VectorString} %s %s" % (param_prefix, - inp['name'], - inp['description'])) - + comment_input_type = "{VectorString}" else: - comments.append("%s {VectorVectorFloat} %s %s" % (param_prefix, - inp['name'], - inp['description'])) - else: - inputs.append("%s: %s" % (inp['name'], map_types_to_js(inp['type']))) + comment_input_type = "{VectorVectorFloat}" - comments.append("%s {%s} %s %s" % (param_prefix, - map_types_to_js(inp['type']), - inp['name'], - inp['description'])) + else: + inputs.append(f"{inp['name']}: {map_types_to_js(inp['type'])}") + comment_input_type = f"{{{map_types_to_js(inp['type'])}}}" + comments.append(f"{param_prefix} {comment_input_type} {inp['name']} {inp['description']}") return_inputs.append(inp['name']) # parse parameter variables for param in doc_dict['parameters']: - comments.append("%s {%s} [%s=%s] %s" % (param_prefix, - map_types_to_js(param['type']), - param['name'], - param['default'], - param['description'])) - + comments.append(f"{param_prefix} {{{map_types_to_js(param['type'])}}} [{param['name']}={param['default']}] {param['description']}") + vec_param_var = f"vec{param['name']}" + param_default_val = param['default'] + param_var_name = param['name'] if param['type'] in ['vector_real', 'vector_complex', 'matrix_real']: - param_converted.append(" let vec%s = new this.module.VectorFloat();" % param['name']) - param_converted.append(" for (var i=0; i A#). Check https://essentia.upf.edu/reference/std_ChordsDetection.html for more details. + * This algorithm estimates chords given an input sequence of harmonic pitch class profiles (HPCPs). It finds the best matching major or minor triad and outputs the result as a string (e.g. A#, Bm, G#m, C). The following note names are used in the output: + "A", "Bb", "B", "C", "C#", "D", "Eb", "E", "F", "F#", "G", "Ab". + Note: + - The algorithm assumes that the sequence of the input HPCP frames has been computed with framesize = 2*hopsize + - The algorithm estimates a sequence of chord values corresponding to the input HPCP frames (one chord value for each frame, estimated using a temporal window of HPCPs centered at that frame). Check https://essentia.upf.edu/reference/std_ChordsDetection.html for more details. * @method * @param {VectorVectorFloat} pcp the pitch class profile from which to detect the chord * @param {number} [hopSize=2048] the hop size with which the input PCPs were computed @@ -531,7 +535,7 @@ class Essentia { - 'starting_beat', chroma vector is sampled from the start of the segment (that is, its starting beat position) using its first frame. It makes sense if chroma is preliminary smoothed. Check https://essentia.upf.edu/reference/std_ChordsDetectionBeats.html for more details. * @method * @param {VectorVectorFloat} pcp the pitch class profile from which to detect the chord - * @param {VectorFloat} ticks the list of beat positions (in seconds) + * @param {VectorFloat} ticks the list of beat positions (in seconds). One chord will be outputted for each segment between two adjacent ticks. If number of ticks is smaller than 2, exception will be thrown. Those ticks that exceeded the pcp time length will be ignored. * @param {string} [chromaPick=interbeat_median] method of calculating singleton chroma for interbeat interval * @param {number} [hopSize=2048] the hop size with which the input PCPs were computed * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] @@ -574,7 +578,7 @@ class Essentia { * @param {number} [sampleRate=44100] FFT sampling rate [Hz] * @param {number} [scale=1] filters scale. Larger values use longer windows * @param {number} [threshold=0.01] bins whose magnitude is below this quantile are discarded - * @param {string} [windowType=hann] the window type, which can be 'hamming', 'hann', 'triangular', 'square' or 'blackmanharrisXX' + * @param {string} [windowType=hann] the window type * @param {boolean} [zeroPhase=true] a boolean value that enables zero-phase windowing. Input audio frames should be windowed with the same phase mode * @returns {object} {chromagram: 'the magnitude constant-Q chromagram'} * @memberof Essentia @@ -621,7 +625,7 @@ class Essentia { * @param {string} [alignmentType=serra09] choose either one of the given local-alignment constraints for smith-waterman algorithm as described in [2] or [3] respectively. * @param {number} [disExtension=0.5] penalty for disruption extension * @param {number} [disOnset=0.5] penalty for disruption onset - * @param {string} [distanceType=asymmetric] choose the type of distance. By default the algorithm outputs a asymmetric disctance which is obtained by normalising the maximum score in the alignment score matrix with length of reference song + * @param {string} [distanceType=asymmetric] choose the type of distance. By default the algorithm outputs a asymmetric distance which is obtained by normalising the maximum score in the alignment score matrix with length of reference song * @returns {object} {scoreMatrix: 'a 2D smith-waterman alignment score matrix from the input binary cross-similarity matrix', distance: 'cover song similarity distance between the query and reference song from the input similarity matrix. Either 'asymmetric' (as described in [2]) or 'symmetric' (maximum score in the alignment score matrix).'} * @memberof Essentia */ @@ -1086,7 +1090,7 @@ class Essentia { } /** - * This algorithm uses energy and time thresholds to detect gaps in the waveform. A median filter is used to remove spurious silent samples. The power of a small audio region before the detected gaps (prepower) is thresholded to detect intentional pauses as described in [1]. This technique isextended to the region after the gap. + * This algorithm uses energy and time thresholds to detect gaps in the waveform. A median filter is used to remove spurious silent samples. The power of a small audio region before the detected gaps (prepower) is thresholded to detect intentional pauses as described in [1]. This technique is extended to the region after the gap. The algorithm was designed for a framewise use and returns the start and end timestamps related to the first frame processed. Call configure() or reset() in order to restart the count. Check https://essentia.upf.edu/reference/std_GapsDetector.html for more details. * @method * @param {VectorFloat} frame the input frame (must be non-empty) @@ -1398,7 +1402,7 @@ class Essentia { * @param {number} [spectralPeaksThreshold=0.0001] the threshold for the spectral peaks * @param {number} [tuningFrequency=440] the tuning frequency of the input signal * @param {string} [weightType=cosine] type of weighting function for determining frequency contribution - * @param {string} [windowType=hann] the window type, which can be 'hamming', 'hann', 'triangular', 'square' or 'blackmanharrisXX' + * @param {string} [windowType=hann] the window type * @returns {object} {key: 'See Key algorithm documentation', scale: 'See Key algorithm documentation', strength: 'See Key algorithm documentation'} * @memberof Essentia */ @@ -1480,20 +1484,21 @@ class Essentia { * @param {VectorFloat} spectrum spectrum frame * @param {number} [binsPerSemitone=3] bins per semitone * @param {number} [frameSize=1025] the input frame size of the spectrum vector + * @param {number} [nOctave=7] the number of octave of the output vector * @param {number} [rollOn=0] this removes low-frequency noise - useful in quiet recordings * @param {number} [sampleRate=44100] the input sample rate * @returns {object} {logFreqSpectrum: 'log frequency spectrum frame', meanTuning: 'normalized mean tuning frequency', localTuning: 'normalized local tuning frequency'} * @memberof Essentia */ - LogSpectrum(spectrum: any, binsPerSemitone: number=3, frameSize: number=1025, rollOn: number=0, sampleRate: number=44100) { - return this.algorithms.LogSpectrum(spectrum, binsPerSemitone, frameSize, rollOn, sampleRate); + LogSpectrum(spectrum: any, binsPerSemitone: number=3, frameSize: number=1025, nOctave: number=7, rollOn: number=0, sampleRate: number=44100) { + return this.algorithms.LogSpectrum(spectrum, binsPerSemitone, frameSize, nOctave, rollOn, sampleRate); } /** * This algorithm takes an audio signal and a BPM estimate for that signal and predicts the reliability of the BPM estimate in a value from 0 to 1. The audio signal is assumed to be a musical loop with constant tempo. The confidence returned is based on comparing the duration of the signal with multiples of the BPM estimate (see [1] for more details). Check https://essentia.upf.edu/reference/std_LoopBpmConfidence.html for more details. * @method * @param {VectorFloat} signal loop audio signal - * @param {number} bpmEstimate estimated BPM for the audio signal + * @param {number} bpmEstimate estimated BPM for the audio signal (will be rounded to nearest integer) * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] * @returns {object} {confidence: 'confidence value for the BPM estimation'} * @memberof Essentia @@ -1615,7 +1620,7 @@ class Essentia { * @method * @param {VectorFloat} signal signal to be filtered * @param {boolean} [causal=true] use casual filter (window is behind current element otherwise it is centered around) - * @param {number} [width=3] the window size, has to be odd if the window is centered + * @param {number} [width=3] the window size, even size is auto-resized to the next odd value in the non-casual case * @returns {object} {signal: 'filtered output'} * @memberof Essentia */ @@ -1687,7 +1692,7 @@ class Essentia { * @param {VectorFloat} spectrum the audio spectrum * @param {number} [highFrequencyBound=22050] an upper-bound limit for the frequencies to be included in the bands * @param {number} [inputSize=1025] the size of the spectrum - * @param {boolean} [log=false] compute log-energies (log10 (1 + energy)) + * @param {boolean} [log=false] compute log-energies (log2 (1 + energy)) * @param {number} [lowFrequencyBound=0] a lower-bound limit for the frequencies to be included in the bands * @param {string} [normalize=unit_sum] spectrum bin weights to use for each mel band: 'unit_max' to make each mel band vertex equal to 1, 'unit_sum' to make each mel band area equal to 1 summing the actual weights of spectrum bins, 'unit_area' to make each triangle mel band area equal to 1 normalizing the weights of each triangle by its bandwidth * @param {number} [numberBands=24] the number of output bands @@ -1784,7 +1789,7 @@ class Essentia { * @param {number} [hopSize=128] the hop size with which the pitch salience function was computed * @param {number} [magnitudeCompression=1] magnitude compression parameter for the salience function (=0 for maximum compression, =1 for no compression) * @param {number} [magnitudeThreshold=40] spectral peak magnitude threshold (maximum allowed difference from the highest peak in dBs) - * @param {number} [maxFrequency=20000] the minimum allowed frequency for salience function peaks (ignore contours with peaks above) [Hz] + * @param {number} [maxFrequency=20000] the maximum allowed frequency for salience function peaks (ignore contours with peaks above) [Hz] * @param {number} [minDuration=100] the minimum allowed contour duration [ms] * @param {number} [minFrequency=40] the minimum allowed frequency for salience function peaks (ignore contours with peaks below) [Hz] * @param {number} [numberHarmonics=20] number of considered harmonics @@ -2024,8 +2029,7 @@ class Essentia { } /** - * This algorithm implements the 'Enhance Harmonics' step as described in [1].Given an input autocorrelation signal, two time-stretched versions of it (by factors of 2 and 4) are added to the original.In this way, peaks with an harmonic relation are boosted. - For more details check the referenced paper. Check https://essentia.upf.edu/reference/std_PercivalEnhanceHarmonics.html for more details. + * This algorithm implements the 'Enhance Harmonics' step as described in [1].Given an input autocorrelation signal, two time-stretched versions of it scaled by factors of 2 and 4 are added to the original.For more details check the referenced paper. Check https://essentia.upf.edu/reference/std_PercivalEnhanceHarmonics.html for more details. * @method * @param {VectorFloat} array the input signal * @returns {object} {array: 'the input signal with enhanced harmonics'} @@ -2036,8 +2040,8 @@ class Essentia { } /** - * This algorithm implements the 'Evaluate Pulse Trains' step as described in [1].Given an input onset strength signal (OSS) and a number of candidate tempo lag positions, the OSS is correlated with ideal expected pulse trains (for each candidate tempo lag) shifted in time by different amounts. The candidate tempo lag which generates the pulse train that better correlates with the OSS is returned as the preferred tempo candidate. - For more details check the referenced paper. Check https://essentia.upf.edu/reference/std_PercivalEvaluatePulseTrains.html for more details. + * This algorithm implements the 'Evaluate Pulse Trains' step as described in [1].Given an input onset detection function (ODF, called "onset strength signal", OSS, in the original paper) and a number of candidate BPM peak positions, the ODF is correlated with ideal expected pulse trains (for each candidate tempo lag) shifted in time by different amounts.The candidate tempo lag that generates a periodic pulse train with the best correlation to the ODF is returned as the best tempo estimate. + For more details check the referenced paper.Please note that in the original paper, the term OSS (Onset Strength Signal) is used instead of ODF. Check https://essentia.upf.edu/reference/std_PercivalEvaluatePulseTrains.html for more details. * @method * @param {VectorFloat} oss onset strength signal (or other novelty curve) * @param {VectorFloat} positions peak positions of BPM candidates @@ -2098,7 +2102,7 @@ class Essentia { * @param {number} [filterIterations=3] number of interations for the octave errors / pitch outlier filtering process * @param {boolean} [guessUnvoiced=false] Estimate pitch for non-voiced segments by using non-salient contours when no salient ones are present in a frame * @param {number} [hopSize=128] the hop size with which the pitch salience function was computed - * @param {number} [maxFrequency=20000] the minimum allowed frequency for salience function peaks (ignore contours with peaks above) [Hz] + * @param {number} [maxFrequency=20000] the maximum allowed frequency for salience function peaks (ignore contours with peaks above) [Hz] * @param {number} [minFrequency=80] the minimum allowed frequency for salience function peaks (ignore contours with peaks below) [Hz] * @param {number} [referenceFrequency=55] the reference frequency for Hertz to cent convertion [Hz], corresponding to the 0th cent bin * @param {number} [sampleRate=44100] the sampling rate of the audio signal (Hz) @@ -2124,7 +2128,7 @@ class Essentia { * @param {number} [filterIterations=3] number of interations for the octave errors / pitch outlier filtering process * @param {boolean} [guessUnvoiced=false] Estimate pitch for non-voiced segments by using non-salient contours when no salient ones are present in a frame * @param {number} [hopSize=128] the hop size with which the pitch salience function was computed - * @param {number} [maxFrequency=20000] the minimum allowed frequency for salience function peaks (ignore contours with peaks above) [Hz] + * @param {number} [maxFrequency=20000] the maximum allowed frequency for salience function peaks (ignore contours with peaks above) [Hz] * @param {number} [minFrequency=80] the minimum allowed frequency for salience function peaks (ignore contours with peaks below) [Hz] * @param {number} [referenceFrequency=55] the reference frequency for Hertz to cent convertion [Hz], corresponding to the 0th cent bin * @param {number} [sampleRate=44100] the sampling rate of the audio signal (Hz) @@ -2147,7 +2151,7 @@ class Essentia { * @param {number} [filterIterations=3] number of interations for the octave errors / pitch outlier filtering process * @param {boolean} [guessUnvoiced=false] Estimate pitch for non-voiced segments by using non-salient contours when no salient ones are present in a frame * @param {number} [hopSize=128] the hop size with which the pitch salience function was computed - * @param {number} [maxFrequency=20000] the minimum allowed frequency for salience function peaks (ignore contours with peaks above) [Hz] + * @param {number} [maxFrequency=20000] the maximum allowed frequency for salience function peaks (ignore contours with peaks above) [Hz] * @param {number} [minFrequency=80] the minimum allowed frequency for salience function peaks (ignore contours with peaks below) [Hz] * @param {number} [referenceFrequency=55] the reference frequency for Hertz to cent convertion [Hz], corresponding to the 0th cent bin * @param {number} [sampleRate=44100] the sampling rate of the audio signal (Hz) @@ -2185,7 +2189,7 @@ class Essentia { * @param {number} [hopSize=128] the hop size with which the pitch salience function was computed * @param {number} [magnitudeCompression=1] magnitude compression parameter for the salience function (=0 for maximum compression, =1 for no compression) * @param {number} [magnitudeThreshold=40] spectral peak magnitude threshold (maximum allowed difference from the highest peak in dBs) - * @param {number} [maxFrequency=20000] the minimum allowed frequency for salience function peaks (ignore contours with peaks above) [Hz] + * @param {number} [maxFrequency=20000] the maximum allowed frequency for salience function peaks (ignore contours with peaks above) [Hz] * @param {number} [minDuration=100] the minimum allowed contour duration [ms] * @param {number} [minFrequency=40] the minimum allowed frequency for salience function peaks (ignore contours with peaks below) [Hz] * @param {number} [numberHarmonics=20] number of considered harmonics @@ -2367,7 +2371,7 @@ class Essentia { * @param {number} [hopSize=128] the hop size with which the pitch salience function was computed * @param {number} [magnitudeCompression=1] magnitude compression parameter for the salience function (=0 for maximum compression, =1 for no compression) * @param {number} [magnitudeThreshold=40] spectral peak magnitude threshold (maximum allowed difference from the highest peak in dBs) - * @param {number} [maxFrequency=20000] the minimum allowed frequency for salience function peaks (ignore contours with peaks above) [Hz] + * @param {number} [maxFrequency=20000] the maximum allowed frequency for salience function peaks (ignore contours with peaks above) [Hz] * @param {number} [minDuration=100] the minimum allowed contour duration [ms] * @param {number} [minFrequency=80] the minimum allowed frequency for salience function peaks (ignore contours with peaks below) [Hz] * @param {number} [numberHarmonics=20] number of considered harmonics @@ -2432,7 +2436,7 @@ class Essentia { * @param {VectorFloat} signal the input signal * @param {number} [inputSampleRate=44100] the sampling rate of the input signal [Hz] * @param {number} [outputSampleRate=44100] the sampling rate of the output signal [Hz] - * @param {number} [quality=1] the quality of the conversion, 0 for best quality + * @param {number} [quality=1] the quality of the conversion, 0 for best quality, 4 for fast linear approximation * @returns {object} {signal: 'the resampled signal'} * @memberof Essentia */ @@ -2441,11 +2445,11 @@ class Essentia { } /** - * This algorithm resamples a sequence using FFT / IFFT. The input and output sizes must be an even number. (It is meant to be eqivalent to the resample function in Numpy). Check https://essentia.upf.edu/reference/std_ResampleFFT.html for more details. + * This algorithm resamples a sequence using FFT/IFFT. The input and output sizes must be an even number. The algorithm is a counterpart of the resample function in SciPy. Check https://essentia.upf.edu/reference/std_ResampleFFT.html for more details. * @method * @param {VectorFloat} input input array - * @param {number} [inSize=128] the size of the input sequence. It needss to be even-sized. - * @param {number} [outSize=128] the size of the output sequence. It needss to be even-sized. + * @param {number} [inSize=128] the size of the input sequence. It needs to be even-sized. + * @param {number} [outSize=128] the size of the output sequence. It needs to be even-sized. * @returns {object} {output: 'output resample array'} * @memberof Essentia */ @@ -2537,12 +2541,7 @@ class Essentia { } /** - * This algorithm computes the SNR of the input audio in a frame-wise manner. The algorithm assumes that: - 1. The noise is gaussian. - 2. There is a region of noise (without signal) at the beginning of the stream in order to estimate the PSD of the noise.[1] - Once the noise PSD is estimated, the algorithm relies on the Ephraim-Malah [2] recursion to estimate the SNR for each frequency bin. - The algorithm also returns an overall (a single value for the whole spectrum) SNR estimation and an averaged overall SNR estimation using Exponential Moving Average filtering. - This algorithm throws a Warning if less than 15 frames are used to estimte the noise PSD. Check https://essentia.upf.edu/reference/std_SNR.html for more details. + * This algorithm computes the SNR of the input audio in a frame-wise manner. Check https://essentia.upf.edu/reference/std_SNR.html for more details. * @method * @param {VectorFloat} frame the input audio frame * @param {number} [MAAlpha=0.95] Alpha coefficient for the EMA SNR estimation [2] @@ -2755,7 +2754,7 @@ class Essentia { * @param {number} [sampleRate=44100] FFT sampling rate [Hz] * @param {number} [scale=1] filters scale. Larger values use longer windows * @param {number} [threshold=0.01] bins whose magnitude is below this quantile are discarded - * @param {string} [windowType=hann] the window type, which can be 'hamming', 'hann', 'triangular', 'square' or 'blackmanharrisXX' + * @param {string} [windowType=hann] the window type * @param {boolean} [zeroPhase=true] a boolean value that enables zero-phase windowing. Input audio frames should be windowed with the same phase mode * @returns {object} {spectrumCQ: 'the magnitude constant-Q spectrum'} * @memberof Essentia @@ -2771,7 +2770,7 @@ class Essentia { * @param {number} [bands=720] number of bins to compute. Default is 720 (6 octaves with the default 'centBinResolution') * @param {number} [centBinResolution=10] Width of each band in cents. Default is 10 cents * @param {number} [inputSize=32768] the size of the spectrum - * @param {boolean} [log=true] compute log-energies (log10 (1 + energy)) + * @param {boolean} [log=true] compute log-energies (log2 (1 + energy)) * @param {number} [minimumFrequency=164] central frequency of the first band of the bank [Hz] * @param {string} [normalize=unit_sum] use unit area or vertex equal to 1 triangles. * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] @@ -3116,7 +3115,18 @@ class Essentia { } /** - * This algorithm computes mel-bands with a particular parametrization specific to MusiCNN based models. Check https://essentia.upf.edu/reference/std_TensorflowInputMusiCNN.html for more details. + * This algorithm computes mel bands from an audio frame with the specific parametrization required by the FSD-SINet models. Check https://essentia.upf.edu/reference/std_TensorflowInputFSDSINet.html for more details. + * @method + * @param {VectorFloat} frame the audio frame + * @returns {object} {bands: 'the log-compressed mel bands'} + * @memberof Essentia + */ + TensorflowInputFSDSINet(frame: any) { + return this.algorithms.TensorflowInputFSDSINet(frame); + } + + /** + * This algorithm computes mel-bands specific to the input of MusiCNN-based models. Check https://essentia.upf.edu/reference/std_TensorflowInputMusiCNN.html for more details. * @method * @param {VectorFloat} frame the audio frame * @returns {object} {bands: 'the log compressed mel bands'} @@ -3127,7 +3137,18 @@ class Essentia { } /** - * This algorithm computes mel-bands with a particular parametrization specific to VGGish based models. Check https://essentia.upf.edu/reference/std_TensorflowInputVGGish.html for more details. + * This algorithm computes mel-bands specific to the input of TempoCNN-based models. Check https://essentia.upf.edu/reference/std_TensorflowInputTempoCNN.html for more details. + * @method + * @param {VectorFloat} frame the audio frame + * @returns {object} {bands: 'the mel bands'} + * @memberof Essentia + */ + TensorflowInputTempoCNN(frame: any) { + return this.algorithms.TensorflowInputTempoCNN(frame); + } + + /** + * This algorithm computes mel-bands specific to the input of VGGish-based models. Check https://essentia.upf.edu/reference/std_TensorflowInputVGGish.html for more details. * @method * @param {VectorFloat} frame the audio frame * @returns {object} {bands: 'the log compressed mel bands'} @@ -3152,7 +3173,7 @@ class Essentia { } /** - * This algorithm estimates the tonic frequency of the lead artist in Indian art music. It uses multipitch representation of the audio signal (pitch salience) to compute a histogram using which the tonic is identified as one of its peak. The decision is made based on the distance between the prominent peaks, the classification is done using a decision tree. Check https://essentia.upf.edu/reference/std_TonicIndianArtMusic.html for more details. + * This algorithm estimates the tonic frequency of the lead artist in Indian art music. It uses multipitch representation of the audio signal (pitch salience) to compute a histogram using which the tonic is identified as one of its peak. The decision is made based on the distance between the prominent peaks, the classification is done using a decision tree. An empty input signal will throw an exception. An exception will also be thrown if no predominant pitch salience peaks are detected within the maxTonicFrequency to minTonicFrequency range. Check https://essentia.upf.edu/reference/std_TonicIndianArtMusic.html for more details. * @method * @param {VectorFloat} signal the input signal * @param {number} [binResolution=10] salience function bin resolution [cents] @@ -3164,7 +3185,7 @@ class Essentia { * @param {number} [maxTonicFrequency=375] the maximum allowed tonic frequency [Hz] * @param {number} [minTonicFrequency=100] the minimum allowed tonic frequency [Hz] * @param {number} [numberHarmonics=20] number of considered hamonics - * @param {number} [numberSaliencePeaks=5] number of top peaks of the salience function which should be considered for constructing histogram + * @param {number} [numberSaliencePeaks=5] number of top peaks of the salience function which should be considered for constructing histogram * @param {number} [referenceFrequency=55] the reference frequency for Hertz to cent convertion [Hz], corresponding to the 0th cent bin * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] * @returns {object} {tonic: 'the estimated tonic frequency [Hz]'} @@ -3180,7 +3201,7 @@ class Essentia { * @param {VectorFloat} spectrum the input spectrum (must be greater than size one) * @param {any[]} [frequencyBands=[21.533203125, 43.06640625, 64.599609375, 86.1328125, 107.666015625, 129.19921875, 150.732421875, 172.265625, 193.798828125, 215.33203125, 236.865234375, 258.3984375, 279.931640625, 301.46484375, 322.998046875, 344.53125, 366.064453125, 387.59765625, 409.130859375, 430.6640625, 452.197265625, 473.73046875, 495.263671875, 516.796875, 538.330078125, 559.86328125, 581.396484375, 602.9296875, 624.462890625, 645.99609375, 667.529296875, 689.0625, 710.595703125, 732.12890625, 753.662109375, 775.1953125, 796.728515625, 839.794921875, 861.328125, 882.861328125, 904.39453125, 925.927734375, 968.994140625, 990.52734375, 1012.06054688, 1055.12695312, 1076.66015625, 1098.19335938, 1141.25976562, 1184.32617188, 1205.859375, 1248.92578125, 1270.45898438, 1313.52539062, 1356.59179688, 1399.65820312, 1442.72460938, 1485.79101562, 1528.85742188, 1571.92382812, 1614.99023438, 1658.05664062, 1701.12304688, 1765.72265625, 1808.7890625, 1873.38867188, 1916.45507812, 1981.0546875, 2024.12109375, 2088.72070312, 2153.3203125, 2217.91992188, 2282.51953125, 2347.11914062, 2411.71875, 2497.8515625, 2562.45117188, 2627.05078125, 2713.18359375, 2799.31640625, 2885.44921875, 2950.04882812, 3036.18164062, 3143.84765625, 3229.98046875, 3316.11328125, 3423.77929688, 3509.91210938, 3617.578125, 3725.24414062, 3832.91015625, 3940.57617188, 4069.77539062, 4177.44140625, 4306.640625, 4435.83984375, 4565.0390625, 4694.23828125, 4844.97070312, 4974.16992188, 5124.90234375, 5275.63476562, 5426.3671875, 5577.09960938, 5749.36523438, 5921.63085938, 6093.89648438, 6266.16210938, 6459.9609375, 6653.75976562, 6847.55859375, 7041.35742188, 7256.68945312, 7450.48828125, 7687.35351562, 7902.68554688, 8139.55078125, 8376.41601562, 8613.28125, 8871.6796875, 9130.078125, 9388.4765625, 9668.40820312, 9948.33984375, 10249.8046875, 10551.2695312, 10852.734375, 11175.7324219, 11498.7304688, 11843.2617188, 12187.7929688, 12553.8574219, 12919.921875, 13285.9863281, 13673.5839844, 14082.7148438, 14491.8457031, 14922.5097656, 15353.1738281, 15805.3710938, 16257.5683594]] list of frequency ranges into which the spectrum is divided (these must be in ascending order and connot contain duplicates),each triangle is build as x(i-1)=0, x(i)=1, x(i+1)=0 over i, the resulting number of bands is size of input array - 2 * @param {number} [inputSize=1025] the size of the spectrum - * @param {boolean} [log=true] compute log-energies (log10 (1 + energy)) + * @param {boolean} [log=true] compute log-energies (log2 (1 + energy)) * @param {string} [normalize=unit_sum] spectrum bin weights to use for each triangular band: 'unit_max' to make each triangle vertex equal to 1, 'unit_sum' to make each triangle area equal to 1 summing the actual weights of spectrum bins, 'unit_area' to make each triangle area equal to 1 normalizing the weights of each triangle by its bandwidth * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] * @param {string} [type=power] use magnitude or power spectrum @@ -3204,7 +3225,7 @@ class Essentia { * @param {VectorFloat} spectrum the audio spectrum * @param {number} [highFrequencyBound=22050] an upper-bound limit for the frequencies to be included in the bands * @param {number} [inputSize=1025] the size of the spectrum - * @param {boolean} [log=false] compute log-energies (log10 (1 + energy)) + * @param {boolean} [log=false] compute log-energies (log2 (1 + energy)) * @param {number} [lowFrequencyBound=0] a lower-bound limit for the frequencies to be included in the bands * @param {string} [normalize=unit_sum] 'unit_max' makes the vertex of all the triangles equal to 1, 'unit_sum' makes the area of all the triangles equal to 1 * @param {number} [numberBands=24] the number of output bands @@ -3389,7 +3410,7 @@ class Essentia { * @param {number} [frameSize=512] the expected size of the input audio signal (this is an optional parameter to optimize memory allocation) * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] * @param {string} [scaling=density] 'density' normalizes the result to the bandwidth while 'power' outputs the unnormalized power spectrum - * @param {string} [windowType=hann] the window type, which can be 'hamming', 'hann', 'triangular', 'square' or 'blackmanharrisXX' + * @param {string} [windowType=hann] the window type * @returns {object} {psd: 'Power Spectral Density [dB] or [dB/Hz]'} * @memberof Essentia */ @@ -3401,16 +3422,19 @@ class Essentia { * This algorithm applies windowing to an audio signal. It optionally applies zero-phase windowing and optionally adds zero-padding. The resulting windowed frame size is equal to the incoming frame size plus the number of padded zeros. By default, the available windows are normalized (to have an area of 1) and then scaled by a factor of 2. Check https://essentia.upf.edu/reference/std_Windowing.html for more details. * @method * @param {VectorFloat} frame the input audio frame + * @param {number} [constantsDecimals=5] number of decimals considered in the constants for the formulation of the hamming and blackmanharris* windows * @param {boolean} [normalized=true] a boolean value to specify whether to normalize windows (to have an area of 1) and then scale by a factor of 2 * @param {number} [size=1024] the window size - * @param {string} [type=hann] the window type, which can be 'hamming', 'hann', 'triangular', 'square' or 'blackmanharrisXX' + * @param {boolean} [splitPadding=false] whether to split the padding to the edges of the signal (_/\_) or to add it to the right (/\__). This option is ignored when zeroPhase (\__/) is true + * @param {boolean} [symmetric=true] whether to create a symmetric or asymmetric window as implemented in SciPy + * @param {string} [type=hann] the window type * @param {number} [zeroPadding=0] the size of the zero-padding * @param {boolean} [zeroPhase=true] a boolean value that enables zero-phase windowing * @returns {object} {frame: 'the windowed audio frame'} * @memberof Essentia */ - Windowing(frame: any, normalized: boolean=true, size: number=1024, type: string='hann', zeroPadding: number=0, zeroPhase: boolean=true) { - return this.algorithms.Windowing(frame, normalized, size, type, zeroPadding, zeroPhase); + Windowing(frame: any, constantsDecimals: number=5, normalized: boolean=true, size: number=1024, splitPadding: boolean=false, symmetric: boolean=true, type: string='hann', zeroPadding: number=0, zeroPhase: boolean=true) { + return this.algorithms.Windowing(frame, constantsDecimals, normalized, size, splitPadding, symmetric, type, zeroPadding, zeroPhase); } /** From 3b0845312a39dd1244bd1044f492f5d2932c9d6f Mon Sep 17 00:00:00 2001 From: Jorge Marcos Date: Mon, 26 Feb 2024 23:47:11 +0100 Subject: [PATCH 06/18] class-based TS api build successful --- package.json | 2 +- src/python/code_generator.py | 70 +- src/python/js_wrapper.cog | 319 +- src/typescript/core_api.ts | 8466 +++++++++++++++++++++------------- 4 files changed, 5470 insertions(+), 3387 deletions(-) diff --git a/package.json b/package.json index ba1b5c6..500c23d 100644 --- a/package.json +++ b/package.json @@ -17,7 +17,7 @@ "scripts": { "gen-code": "make -f Makefile codegen", "build-wasm": "make -f Makefile build", - "build-js-api": "rollup --config", + "build-js-api": "ESSENTIAJS_ADDON=0 rollup --config", "build-api-docs": "./build-docs.sh", "test": "mocha" }, diff --git a/src/python/code_generator.py b/src/python/code_generator.py index f7c1b14..d49c156 100644 --- a/src/python/code_generator.py +++ b/src/python/code_generator.py @@ -293,21 +293,22 @@ def parse_to_typescript(algorithm_name): inputs = list() parameters = list() param_converted = list() - return_inputs = list() - return_parameters = list() + untyped_inputs = list() + untyped_parameters = list() comments = list() algorithm = list() # create the algorithm object algo = getattr(estd, algorithm_name)() doc_dict = algo.getStruct() - doc_link = " Check https://essentia.upf.edu/reference/std_%s.html for more details." % algorithm_name + wasmBackendVar = "wasmBackend" + doc_link = f" Check https://essentia.upf.edu/reference/std_{algorithm_name}.html for more details." # We do a shim of algorithm description for prettifying the doc algo_description = doc_dict['description'].split('\n\n')[0] + doc_link # add jsdoc string comments.append("/**") comments.append("* %s" % algo_description) - comments.append("* @method") + comments.append("* @class") param_prefix = "* @param" return_prefix = "* @returns" @@ -338,7 +339,7 @@ def parse_to_typescript(algorithm_name): comment_input_type = f"{{{map_types_to_js(inp['type'])}}}" comments.append(f"{param_prefix} {comment_input_type} {inp['name']} {inp['description']}") - return_inputs.append(inp['name']) + untyped_inputs.append(inp['name']) # parse parameter variables for param in doc_dict['parameters']: @@ -348,18 +349,18 @@ def parse_to_typescript(algorithm_name): param_default_val = param['default'] param_var_name = param['name'] if param['type'] in ['vector_real', 'vector_complex', 'matrix_real']: - param_converted.append(f" let {vec_param_var} = new this.module.VectorFloat();") - param_converted.append(f" for (var i=0; i<{vec_param_var}.size(); i++) {{") - param_converted.append(f" {vec_param_var}.push_back({param['name']}[i]);") - param_converted.append(" }") + param_converted.append(f" let {vec_param_var} = new {wasmBackendVar}.VectorFloat();") + param_converted.append(f" for (var i=0; i<{vec_param_var}.size(); i++) {{") + param_converted.append(f" {vec_param_var}.push_back({param['name']}[i]);") + param_converted.append(" }") param_var_name = vec_param_var elif param['type'] in ['vector_string']: - param_converted.append(f" let {vec_param_var} = new this.module.VectorString();") - param_converted.append(f" for (var i=0; i<{vec_param_var}.size(); i++) {{") - param_converted.append(f" {vec_param_var}.push_back({param['name']}[i]);") - param_converted.append(" }") + param_converted.append(f" let {vec_param_var} = new {wasmBackendVar}.VectorString();") + param_converted.append(f" for (var i=0; i<{vec_param_var}.size(); i++) {{") + param_converted.append(f" {vec_param_var}.push_back({param['name']}[i]);") + param_converted.append(" }") param_var_name = vec_param_var @@ -367,7 +368,7 @@ def parse_to_typescript(algorithm_name): param_default_val = f"'{param['default']}'" parameters.append(f"{param['name']}: {map_types_to_js(param['type'])}={param_default_val}") - return_parameters.append(param_var_name) + untyped_parameters.append(param_var_name) # parse output variables outs = list() @@ -378,27 +379,40 @@ def parse_to_typescript(algorithm_name): comments.append("* @memberof Essentia") comments.append("*/") - if inputs and parameters: - in_arg_str = f"{', '.join(inputs)}, {', '.join(parameters)}" - return_arg_str = f"{', '.join(return_inputs)}, {', '.join(return_parameters)}" - elif inputs: - in_arg_str = ', '.join(inputs) - return_arg_str = ', '.join(return_inputs) - else: - in_arg_str = ', '.join(parameters) - return_arg_str = ', '.join(return_parameters) + # Add the comments to the algorithm list + algorithm.extend(comments) - func_definition = f"{algorithm_name}({in_arg_str})" - return_definition = f"return {JS_ALGORITHMS_RETURN_NAMESPACE}.{algorithm_name}({return_arg_str});" + # Generate the class definition + class_definition = f"class {algorithm_name} {{" + algorithm.append(class_definition) + algorithm.append(" private algoInstance: any;") - algorithm.extend(comments) - algorithm.append(f"{func_definition} {{") + config_param_list = ', '.join(untyped_parameters) + # Add the constructor + constructor_args = ', '.join(parameters) + algorithm.append(f" constructor({constructor_args}) {{") + if param_converted: + algorithm.extend(param_converted) + algorithm.append(f" this.algoInstance = new wasmBackend.{algorithm_name}({config_param_list});") + algorithm.append(" }") + # Add configure method + algorithm.append(f" configure({constructor_args}) {{") if param_converted: algorithm.extend(param_converted) + algorithm.append(f" this.algoInstance.configure({config_param_list});") + algorithm.append(" }") + + # Add the compute method + compute_args = ', '.join(inputs) + algorithm.append(f" compute({compute_args}) {{") + algorithm.append(f" return this.algoInstance.compute({', '.join(untyped_inputs)});") + algorithm.append(" }") - algorithm.append(f" {return_definition}") + # Close the class definition algorithm.append("}") + + return algorithm diff --git a/src/python/js_wrapper.cog b/src/python/js_wrapper.cog index d7d5aa1..d8e9cc6 100644 --- a/src/python/js_wrapper.cog +++ b/src/python/js_wrapper.cog @@ -20,196 +20,189 @@ // NOTE: The following code snippets are machine generated. Do not edit. +let wasmBackend: any; + +function ready(EssentiaWASM: any) { + wasmBackend = EssentiaWASM; + wasmBackend.init(); +} + + /** - * essentia.js-core JS API - * @class - * @example - * const essentia = new Essentia(EssentiaWASM); + * Decode and returns the audio buffer of a given audio url or blob uri using Web Audio API. + * (NOTE: This method doesn't works on Safari browser) + * @async + * @method + * @param {string} audioURL web url or blob uri of a audio file + * @param {AudioContext} webAudioCtx an instance of Web Audio API `AudioContext` + * @returns {AudioBuffer} decoded audio buffer object + * @memberof Essentia */ -class Essentia { - /** - * @property {EssentiaEmscriptenModule} this.module Essentia WASM emcripten global module object - * @property {string} this.version Essentia WASM backend version - * @property {string} this.algorithmNames List of available Essentia alogrithms from the WASM backend - */ - private algorithms: any; - public module: any; - public version: string; - public algorithmNames: string; - - /** - * @constructs - * @param {EssentiaWASM} Essentia WASM backend (emcripten global module object) which is loaded from 'essentia-wasm.*.js file' - * @param {boolean} [isDebug=false] - */ - constructor(public EssentiaWASM: any, public isDebug: boolean=false) { - this.algorithms = new EssentiaWASM.EssentiaJS(isDebug); - this.module = EssentiaWASM; - this.version = this.algorithms.version; - this.algorithmNames = this.algorithms.algorithmNames; - } +async function getAudioBufferFromURL(audioURL: string, webAudioCtx: AudioContext) { + const response = await fetch(audioURL); + const arrayBuffer = await response.arrayBuffer(); + const audioBuffer = await webAudioCtx.decodeAudioData(arrayBuffer); + return audioBuffer; +} - /** - * Decode and returns the audio buffer of a given audio url or blob uri using Web Audio API. - * (NOTE: This method doesn't works on Safari browser) - * @async - * @method - * @param {string} audioURL web url or blob uri of a audio file - * @param {AudioContext} webAudioCtx an instance of Web Audio API `AudioContext` - * @returns {AudioBuffer} decoded audio buffer object - * @memberof Essentia - */ - async getAudioBufferFromURL(audioURL: string, webAudioCtx: AudioContext) { - const response = await fetch(audioURL); - const arrayBuffer = await response.arrayBuffer(); - const audioBuffer = await webAudioCtx.decodeAudioData(arrayBuffer); - return audioBuffer; - } +/** + * Decode and returns the audio channel data from an given audio url or blob uri using Web Audio API. + * (NOTE: This method doesn't works on Safari browser) + * @async + * @method + * @param {string} audioURL web url or blob uri of a audio file + * @param {AudioContext} webAudioCtx an instance of Web Audio API `AudioContext` + * @param {number} [channel=0] audio channel number + * @returns {Float32Array} decode and returns the audio data as Float32 array for the given channel + * @memberof Essentia + */ +async function getAudioChannelDataFromURL(audioURL: string, webAudioCtx: AudioContext, channel: number=0) { + const response = await fetch(audioURL); + const arrayBuffer = await response.arrayBuffer(); + const audioBuffer = await webAudioCtx.decodeAudioData(arrayBuffer); + return audioBuffer.getChannelData(channel); +} - /** - * Decode and returns the audio channel data from an given audio url or blob uri using Web Audio API. - * (NOTE: This method doesn't works on Safari browser) - * @async - * @method - * @param {string} audioURL web url or blob uri of a audio file - * @param {AudioContext} webAudioCtx an instance of Web Audio API `AudioContext` - * @param {number} [channel=0] audio channel number - * @returns {Float32Array} decode and returns the audio data as Float32 array for the given channel - * @memberof Essentia - */ - async getAudioChannelDataFromURL(audioURL: string, webAudioCtx: AudioContext, channel: number=0) { - const response = await fetch(audioURL); - const arrayBuffer = await response.arrayBuffer(); - const audioBuffer = await webAudioCtx.decodeAudioData(arrayBuffer); - return audioBuffer.getChannelData(channel); +/** + * Convert an AudioBuffer object to a Mono audio signal array. The audio signal is downmixed + * to mono using essentia `MonoMixer` algorithm if the audio buffer has 2 channels of audio. + * Throws an expection if the input AudioBuffer object has more than 2 channels of audio. + * @method + * @param {AudioBuffer} buffer `AudioBuffer` object decoded from an audio file. + * @returns {Float32Array} audio channel data. (downmixed to mono if its stereo signal). + * @memberof Essentia + */ +function audioBufferToMonoSignal(buffer: AudioBuffer): Float32Array { + if (buffer.numberOfChannels === 1) { + return buffer.getChannelData(0); } - - /** - * Convert an AudioBuffer object to a Mono audio signal array. The audio signal is downmixed - * to mono using essentia `MonoMixer` algorithm if the audio buffer has 2 channels of audio. - * Throws an expection if the input AudioBuffer object has more than 2 channels of audio. - * @method - * @param {AudioBuffer} buffer `AudioBuffer` object decoded from an audio file. - * @returns {Float32Array} audio channel data. (downmixed to mono if its stereo signal). - * @memberof Essentia - */ - audioBufferToMonoSignal(buffer: AudioBuffer): Float32Array { - if (buffer.numberOfChannels === 1) { - return buffer.getChannelData(0); - } - if (buffer.numberOfChannels === 2) { - const left = this.arrayToVector(buffer.getChannelData(0)); - const right = this.arrayToVector(buffer.getChannelData(1)); - let monoSignal = this.MonoMixer(left, right).audio; - return this.vectorToArray(monoSignal); - } - throw new Error('Unexpected number of channels found in audio buffer. Only accepts mono or stereo audio buffers.'); + if (buffer.numberOfChannels === 2) { + const left = wasmBackend.arrayToVector(buffer.getChannelData(0)); + const right = wasmBackend.arrayToVector(buffer.getChannelData(1)); + let monoSignal = wasmBackend.MonoMixer(left, right).audio; + return wasmBackend.vectorToArray(monoSignal); } + throw new Error('Unexpected number of channels found in audio buffer. Only accepts mono or stereo audio buffers.'); +} - /** - * Method to shutdown essentia algorithm instance after it's use - * @method - * @memberof Essentia - */ - shutdown(): void { - this.algorithms.shutdown(); - } +/** + * Convert an input JS array into VectorFloat type + * @method + * @param {Float32Array} inputArray input JS typed array + * @returns {VectorFloat} returns vector float + * @memberof Essentia + */ +function arrayToVector(inputArray: any) { + return wasmBackend.arrayToVector(inputArray); +} - /** - * Method for re-instantiating essentia algorithms instance after using the shutdown method - * @method - * @memberof Essentia - */ - reinstantiate(): void { - this.algorithms = new this.module.EssentiaJS(this.isDebug); - } +/** + * Convert an input VectorFloat array into typed JS Float32Array + * @method + * @param {VectorFloat} inputVector input VectorFloat array + * @returns {Float32Array} returns converted JS typed array + * @memberof Essentia + */ +function vectorToArray(inputVector: any): Float32Array { + return wasmBackend.vectorToArray(inputVector); +} - /** - * Delete essentiajs class instance - * @method - * @memberof Essentia - */ - delete(): void { - this.algorithms.delete(); - } +/** + * Cuts an audio signal data into overlapping frames given frame size and hop size + * @class + */ +class FrameGenerator { + private algoInstance: any; /** - * Convert an input JS array into VectorFloat type - * @method - * @param {Float32Array} inputArray input JS typed array - * @returns {VectorFloat} returns vector float - * @memberof Essentia - */ - arrayToVector(inputArray: any) { - return this.module.arrayToVector(inputArray); + * @constructs + * @param {number} [frameSize=2048] frame size for cutting the audio signal + * @param {number} [hopSize=1024] size of overlapping frame + */ + constructor(frameSize: number=2048, hopSize: number=1024) { + this.algoInstance = new wasmBackend.FrameGenerator(frameSize, hopSize); } /** - * Convert an input VectorFloat array into typed JS Float32Array - * @method - * @param {VectorFloat} inputVector input VectorFloat array - * @returns {Float32Array} returns converted JS typed array - * @memberof Essentia + * Configure algorithm + * @method + * @param {number} [frameSize=2048] frame size for cutting the audio signal + * @param {number} [hopSize=1024] size of overlapping frame + * @memberof FrameGenerator */ - vectorToArray(inputVector: any): Float32Array { - return this.module.vectorToArray(inputVector); + configure(frameSize: number=2048, hopSize: number=1024) { + this.algoInstance.configure(frameSize, hopSize); } /** - * Cuts an audio signal data into overlapping frames given frame size and hop size + * Execute algorithm * @method * @param {Float32Array} inputAudioData a single channel audio channel data - * @param {number} [frameSize=2048] frame size for cutting the audio signal - * @param {number} [hopSize=1024] size of overlapping frame - * @returns {VectorVectorFloat} Returns a 2D vector float of sliced audio frames - * @memberof Essentia + * @returns {VectorVectorFloat} Returns a 2D vector float of sliced audio frames + * @memberof FrameGenerator */ - FrameGenerator(inputAudioData: Float32Array, frameSize: number=2048, hopSize: number=1024) { - return this.algorithms.FrameGenerator(inputAudioData, frameSize, hopSize); + compute(inputAudioData: Float32Array) { + return this.algoInstance.compute(inputAudioData); } +} - /** - * This algorithm downmixes the signal into a single channel given a stereo signal. It is a wrapper around https://essentia.upf.edu/reference/std_MonoMixer.html. - * @method - * @param {VectorFloat} leftChannel the left channel of the stereo audio signal - * @param {VectorFloat} rightChannel the right channel of the stereo audio signal - * @returns {object} {audio: 'the downmixed mono signal'} - * @memberof Essentia - */ - MonoMixer(leftSignal: any, rightSignal: any) { - return this.algorithms.MonoMixer(leftSignal, rightSignal); - } +/** +* This algorithm downmixes the signal into a single channel given a stereo signal. It is a wrapper around https://essentia.upf.edu/reference/std_MonoMixer.html. +* @method +* @param {VectorFloat} leftChannel the left channel of the stereo audio signal +* @param {VectorFloat} rightChannel the right channel of the stereo audio signal +* @returns {object} {audio: 'the downmixed mono signal'} +* @memberof Essentia +*/ +// MonoMixer(leftSignal: any, rightSignal: any) { +// return this.algorithms.MonoMixer(leftSignal, rightSignal); +// } - /** - * This algorithm computes the EBUR128 loudness descriptors of an audio signal. It is a wrapper around https://essentia.upf.edu/reference/std_LoudnessEBUR128.html. - * @method - * @param {VectorFloat} leftChannel the left channel of the stereo audio signal - * @param {VectorFloat} rightChannel the right channel of the stereo audio signal - * @param {number} [hopSize=0.1] the hop size with which the loudness is computed [s] - * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] - * @param {boolean} [startAtZero=false] start momentary/short-term loudness estimation at time 0 (zero-centered loudness estimation windows) if true; otherwise start both windows at time 0 (time positions for momentary and short-term values will not be syncronized) - * @returns {object} {momentaryLoudness: 'momentary loudness (over 400ms) (LUFS)', shortTermLoudness: 'short-term loudness (over 3 seconds) (LUFS)', integratedLoudness: 'integrated loudness (overall) (LUFS)', loudnessRange: 'loudness range over an arbitrary long time interval [3] (dB, LU)'} - * @memberof Essentia - */ - LoudnessEBUR128(leftSignal: any, rightSignal: any, hopSize: number=0.1, sampleRate: number=44100, startAtZero: boolean=false) { - return this.algorithms.LoudnessEBUR128(leftSignal, rightSignal, hopSize, sampleRate, startAtZero); - } +/** +* This algorithm computes the EBUR128 loudness descriptors of an audio signal. It is a wrapper around https://essentia.upf.edu/reference/std_LoudnessEBUR128.html. +* @method +* @param {VectorFloat} leftChannel the left channel of the stereo audio signal +* @param {VectorFloat} rightChannel the right channel of the stereo audio signal +* @param {number} [hopSize=0.1] the hop size with which the loudness is computed [s] +* @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] +* @param {boolean} [startAtZero=false] start momentary/short-term loudness estimation at time 0 (zero-centered loudness estimation windows) if true; otherwise start both windows at time 0 (time positions for momentary and short-term values will not be syncronized) +* @returns {object} {momentaryLoudness: 'momentary loudness (over 400ms) (LUFS)', shortTermLoudness: 'short-term loudness (over 3 seconds) (LUFS)', integratedLoudness: 'integrated loudness (overall) (LUFS)', loudnessRange: 'loudness range over an arbitrary long time interval [3] (dB, LU)'} +* @memberof Essentia +*/ +// LoudnessEBUR128(leftSignal: any, rightSignal: any, hopSize: number=0.1, sampleRate: number=44100, startAtZero: boolean=false) { +// return this.algorithms.LoudnessEBUR128(leftSignal, rightSignal, hopSize, sampleRate, startAtZero); +// } + +// NOTE: The following code snippets are machine generated. Do not edit. +/*[[[cog +import cog +from code_generator import generate_typescript_wrapper +algos = generate_typescript_wrapper() +for algo in algos: + for ln in algo: + cog.outl(ln) + cog.outl(' ') +]]]*/ +//[[[end]]] - // NOTE: The following code snippets are machine generated. Do not edit. - /*[[[cog - import cog - from code_generator import generate_typescript_wrapper - algos = generate_typescript_wrapper() - for algo in algos: - for ln in algo: - cog.outl(ln) - cog.outl(' ') - ]]]*/ - //[[[end]]] -} /* @exports */ -export default Essentia; \ No newline at end of file +export { + getAudioBufferFromURL, + getAudioChannelDataFromURL, + audioBufferToMonoSignal, + arrayToVector, + vectorToArray, + FrameGenerator, + /*[[[cog + import cog + from configure_bindings import TO_INCLUDE_ALGOS + for algo in TO_INCLUDE_ALGOS: + cog.outl(f"{algo},") + ]]]*/ + //[[[end]]] + ready +}; \ No newline at end of file diff --git a/src/typescript/core_api.ts b/src/typescript/core_api.ts index b9a1068..974c202 100644 --- a/src/typescript/core_api.ts +++ b/src/typescript/core_api.ts @@ -20,3440 +20,5516 @@ // NOTE: The following code snippets are machine generated. Do not edit. +let wasmBackend: any; + +function ready(EssentiaWASM: any) { + wasmBackend = EssentiaWASM; + wasmBackend.init(); +} + + /** - * essentia.js-core JS API - * @class - * @example - * const essentia = new Essentia(EssentiaWASM); + * Decode and returns the audio buffer of a given audio url or blob uri using Web Audio API. + * (NOTE: This method doesn't works on Safari browser) + * @async + * @method + * @param {string} audioURL web url or blob uri of a audio file + * @param {AudioContext} webAudioCtx an instance of Web Audio API `AudioContext` + * @returns {AudioBuffer} decoded audio buffer object + * @memberof Essentia */ -class Essentia { - /** - * @property {EssentiaEmscriptenModule} this.module Essentia WASM emcripten global module object - * @property {string} this.version Essentia WASM backend version - * @property {string} this.algorithmNames List of available Essentia alogrithms from the WASM backend - */ - private algorithms: any; - public module: any; - public version: string; - public algorithmNames: string; +async function getAudioBufferFromURL(audioURL: string, webAudioCtx: AudioContext) { + const response = await fetch(audioURL); + const arrayBuffer = await response.arrayBuffer(); + const audioBuffer = await webAudioCtx.decodeAudioData(arrayBuffer); + return audioBuffer; +} - /** - * @constructs - * @param {EssentiaWASM} Essentia WASM backend (emcripten global module object) which is loaded from 'essentia-wasm.*.js file' - * @param {boolean} [isDebug=false] - */ - constructor(public EssentiaWASM: any, public isDebug: boolean=false) { - this.algorithms = new EssentiaWASM.EssentiaJS(isDebug); - this.module = EssentiaWASM; - this.version = this.algorithms.version; - this.algorithmNames = this.algorithms.algorithmNames; - } +/** + * Decode and returns the audio channel data from an given audio url or blob uri using Web Audio API. + * (NOTE: This method doesn't works on Safari browser) + * @async + * @method + * @param {string} audioURL web url or blob uri of a audio file + * @param {AudioContext} webAudioCtx an instance of Web Audio API `AudioContext` + * @param {number} [channel=0] audio channel number + * @returns {Float32Array} decode and returns the audio data as Float32 array for the given channel + * @memberof Essentia + */ +async function getAudioChannelDataFromURL(audioURL: string, webAudioCtx: AudioContext, channel: number=0) { + const response = await fetch(audioURL); + const arrayBuffer = await response.arrayBuffer(); + const audioBuffer = await webAudioCtx.decodeAudioData(arrayBuffer); + return audioBuffer.getChannelData(channel); +} - /** - * Decode and returns the audio buffer of a given audio url or blob uri using Web Audio API. - * (NOTE: This method doesn't works on Safari browser) - * @async - * @method - * @param {string} audioURL web url or blob uri of a audio file - * @param {AudioContext} webAudioCtx an instance of Web Audio API `AudioContext` - * @returns {AudioBuffer} decoded audio buffer object - * @memberof Essentia - */ - async getAudioBufferFromURL(audioURL: string, webAudioCtx: AudioContext) { - const response = await fetch(audioURL); - const arrayBuffer = await response.arrayBuffer(); - const audioBuffer = await webAudioCtx.decodeAudioData(arrayBuffer); - return audioBuffer; +/** + * Convert an AudioBuffer object to a Mono audio signal array. The audio signal is downmixed + * to mono using essentia `MonoMixer` algorithm if the audio buffer has 2 channels of audio. + * Throws an expection if the input AudioBuffer object has more than 2 channels of audio. + * @method + * @param {AudioBuffer} buffer `AudioBuffer` object decoded from an audio file. + * @returns {Float32Array} audio channel data. (downmixed to mono if its stereo signal). + * @memberof Essentia + */ +function audioBufferToMonoSignal(buffer: AudioBuffer): Float32Array { + if (buffer.numberOfChannels === 1) { + return buffer.getChannelData(0); } - - /** - * Decode and returns the audio channel data from an given audio url or blob uri using Web Audio API. - * (NOTE: This method doesn't works on Safari browser) - * @async - * @method - * @param {string} audioURL web url or blob uri of a audio file - * @param {AudioContext} webAudioCtx an instance of Web Audio API `AudioContext` - * @param {number} [channel=0] audio channel number - * @returns {Float32Array} decode and returns the audio data as Float32 array for the given channel - * @memberof Essentia - */ - async getAudioChannelDataFromURL(audioURL: string, webAudioCtx: AudioContext, channel: number=0) { - const response = await fetch(audioURL); - const arrayBuffer = await response.arrayBuffer(); - const audioBuffer = await webAudioCtx.decodeAudioData(arrayBuffer); - return audioBuffer.getChannelData(channel); + if (buffer.numberOfChannels === 2) { + const left = wasmBackend.arrayToVector(buffer.getChannelData(0)); + const right = wasmBackend.arrayToVector(buffer.getChannelData(1)); + let monoSignal = wasmBackend.MonoMixer(left, right).audio; + return wasmBackend.vectorToArray(monoSignal); } + throw new Error('Unexpected number of channels found in audio buffer. Only accepts mono or stereo audio buffers.'); +} - /** - * Convert an AudioBuffer object to a Mono audio signal array. The audio signal is downmixed - * to mono using essentia `MonoMixer` algorithm if the audio buffer has 2 channels of audio. - * Throws an expection if the input AudioBuffer object has more than 2 channels of audio. - * @method - * @param {AudioBuffer} buffer `AudioBuffer` object decoded from an audio file. - * @returns {Float32Array} audio channel data. (downmixed to mono if its stereo signal). - * @memberof Essentia - */ - audioBufferToMonoSignal(buffer: AudioBuffer): Float32Array { - if (buffer.numberOfChannels === 1) { - return buffer.getChannelData(0); - } - if (buffer.numberOfChannels === 2) { - const left = this.arrayToVector(buffer.getChannelData(0)); - const right = this.arrayToVector(buffer.getChannelData(1)); - let monoSignal = this.MonoMixer(left, right).audio; - return this.vectorToArray(monoSignal); - } - throw new Error('Unexpected number of channels found in audio buffer. Only accepts mono or stereo audio buffers.'); - } +/** + * Convert an input JS array into VectorFloat type + * @method + * @param {Float32Array} inputArray input JS typed array + * @returns {VectorFloat} returns vector float + * @memberof Essentia + */ +function arrayToVector(inputArray: any) { + return wasmBackend.arrayToVector(inputArray); +} - /** - * Method to shutdown essentia algorithm instance after it's use - * @method - * @memberof Essentia - */ - shutdown(): void { - this.algorithms.shutdown(); - } +/** + * Convert an input VectorFloat array into typed JS Float32Array + * @method + * @param {VectorFloat} inputVector input VectorFloat array + * @returns {Float32Array} returns converted JS typed array + * @memberof Essentia + */ +function vectorToArray(inputVector: any): Float32Array { + return wasmBackend.vectorToArray(inputVector); +} - /** - * Method for re-instantiating essentia algorithms instance after using the shutdown method - * @method - * @memberof Essentia - */ - reinstantiate(): void { - this.algorithms = new this.module.EssentiaJS(this.isDebug); - } +/** + * Cuts an audio signal data into overlapping frames given frame size and hop size + * @class + */ +class FrameGenerator { + private algoInstance: any; /** - * Delete essentiajs class instance - * @method - * @memberof Essentia - */ - delete(): void { - this.algorithms.delete(); + * @constructs + * @param {number} [frameSize=2048] frame size for cutting the audio signal + * @param {number} [hopSize=1024] size of overlapping frame + */ + constructor(frameSize: number=2048, hopSize: number=1024) { + this.algoInstance = new wasmBackend.FrameGenerator(frameSize, hopSize); } /** - * Convert an input JS array into VectorFloat type + * Configure algorithm * @method - * @param {Float32Array} inputArray input JS typed array - * @returns {VectorFloat} returns vector float - * @memberof Essentia - */ - arrayToVector(inputArray: any) { - return this.module.arrayToVector(inputArray); - } - - /** - * Convert an input VectorFloat array into typed JS Float32Array - * @method - * @param {VectorFloat} inputVector input VectorFloat array - * @returns {Float32Array} returns converted JS typed array - * @memberof Essentia + * @param {number} [frameSize=2048] frame size for cutting the audio signal + * @param {number} [hopSize=1024] size of overlapping frame + * @memberof FrameGenerator */ - vectorToArray(inputVector: any): Float32Array { - return this.module.vectorToArray(inputVector); + configure(frameSize: number=2048, hopSize: number=1024) { + this.algoInstance.configure(frameSize, hopSize); } /** - * Cuts an audio signal data into overlapping frames given frame size and hop size + * Execute algorithm * @method * @param {Float32Array} inputAudioData a single channel audio channel data - * @param {number} [frameSize=2048] frame size for cutting the audio signal - * @param {number} [hopSize=1024] size of overlapping frame - * @returns {VectorVectorFloat} Returns a 2D vector float of sliced audio frames - * @memberof Essentia + * @returns {VectorVectorFloat} Returns a 2D vector float of sliced audio frames + * @memberof FrameGenerator */ - FrameGenerator(inputAudioData: Float32Array, frameSize: number=2048, hopSize: number=1024) { - return this.algorithms.FrameGenerator(inputAudioData, frameSize, hopSize); + compute(inputAudioData: Float32Array) { + return this.algoInstance.compute(inputAudioData); } +} - /** - * This algorithm downmixes the signal into a single channel given a stereo signal. It is a wrapper around https://essentia.upf.edu/reference/std_MonoMixer.html. - * @method - * @param {VectorFloat} leftChannel the left channel of the stereo audio signal - * @param {VectorFloat} rightChannel the right channel of the stereo audio signal - * @returns {object} {audio: 'the downmixed mono signal'} - * @memberof Essentia - */ - MonoMixer(leftSignal: any, rightSignal: any) { - return this.algorithms.MonoMixer(leftSignal, rightSignal); - } +/** +* This algorithm downmixes the signal into a single channel given a stereo signal. It is a wrapper around https://essentia.upf.edu/reference/std_MonoMixer.html. +* @method +* @param {VectorFloat} leftChannel the left channel of the stereo audio signal +* @param {VectorFloat} rightChannel the right channel of the stereo audio signal +* @returns {object} {audio: 'the downmixed mono signal'} +* @memberof Essentia +*/ +// MonoMixer(leftSignal: any, rightSignal: any) { +// return this.algorithms.MonoMixer(leftSignal, rightSignal); +// } - /** - * This algorithm computes the EBUR128 loudness descriptors of an audio signal. It is a wrapper around https://essentia.upf.edu/reference/std_LoudnessEBUR128.html. - * @method - * @param {VectorFloat} leftChannel the left channel of the stereo audio signal - * @param {VectorFloat} rightChannel the right channel of the stereo audio signal - * @param {number} [hopSize=0.1] the hop size with which the loudness is computed [s] - * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] - * @param {boolean} [startAtZero=false] start momentary/short-term loudness estimation at time 0 (zero-centered loudness estimation windows) if true; otherwise start both windows at time 0 (time positions for momentary and short-term values will not be syncronized) - * @returns {object} {momentaryLoudness: 'momentary loudness (over 400ms) (LUFS)', shortTermLoudness: 'short-term loudness (over 3 seconds) (LUFS)', integratedLoudness: 'integrated loudness (overall) (LUFS)', loudnessRange: 'loudness range over an arbitrary long time interval [3] (dB, LU)'} - * @memberof Essentia - */ - LoudnessEBUR128(leftSignal: any, rightSignal: any, hopSize: number=0.1, sampleRate: number=44100, startAtZero: boolean=false) { - return this.algorithms.LoudnessEBUR128(leftSignal, rightSignal, hopSize, sampleRate, startAtZero); - } +/** +* This algorithm computes the EBUR128 loudness descriptors of an audio signal. It is a wrapper around https://essentia.upf.edu/reference/std_LoudnessEBUR128.html. +* @method +* @param {VectorFloat} leftChannel the left channel of the stereo audio signal +* @param {VectorFloat} rightChannel the right channel of the stereo audio signal +* @param {number} [hopSize=0.1] the hop size with which the loudness is computed [s] +* @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] +* @param {boolean} [startAtZero=false] start momentary/short-term loudness estimation at time 0 (zero-centered loudness estimation windows) if true; otherwise start both windows at time 0 (time positions for momentary and short-term values will not be syncronized) +* @returns {object} {momentaryLoudness: 'momentary loudness (over 400ms) (LUFS)', shortTermLoudness: 'short-term loudness (over 3 seconds) (LUFS)', integratedLoudness: 'integrated loudness (overall) (LUFS)', loudnessRange: 'loudness range over an arbitrary long time interval [3] (dB, LU)'} +* @memberof Essentia +*/ +// LoudnessEBUR128(leftSignal: any, rightSignal: any, hopSize: number=0.1, sampleRate: number=44100, startAtZero: boolean=false) { +// return this.algorithms.LoudnessEBUR128(leftSignal, rightSignal, hopSize, sampleRate, startAtZero); +// } - // NOTE: The following code snippets are machine generated. Do not edit. - /** - * This algorithm computes the ratio between the pitch energy after the pitch maximum and the pitch energy before the pitch maximum. Sounds having an monotonically ascending pitch or one unique pitch will show a value of (0,1], while sounds having a monotonically descending pitch will show a value of [1,inf). In case there is no energy before the max pitch, the algorithm will return the energy after the maximum pitch. Check https://essentia.upf.edu/reference/std_AfterMaxToBeforeMaxEnergyRatio.html for more details. - * @method - * @param {VectorFloat} pitch the array of pitch values [Hz] - * @returns {object} {afterMaxToBeforeMaxEnergyRatio: 'the ratio between the pitch energy after the pitch maximum to the pitch energy before the pitch maximum'} - * @memberof Essentia - */ - AfterMaxToBeforeMaxEnergyRatio(pitch: any) { - return this.algorithms.AfterMaxToBeforeMaxEnergyRatio(pitch); +// NOTE: The following code snippets are machine generated. Do not edit. +/** +* This algorithm computes the ratio between the pitch energy after the pitch maximum and the pitch energy before the pitch maximum. Sounds having an monotonically ascending pitch or one unique pitch will show a value of (0,1], while sounds having a monotonically descending pitch will show a value of [1,inf). In case there is no energy before the max pitch, the algorithm will return the energy after the maximum pitch. Check https://essentia.upf.edu/reference/std_AfterMaxToBeforeMaxEnergyRatio.html for more details. +* @class +* @param {VectorFloat} pitch the array of pitch values [Hz] +* @returns {object} {afterMaxToBeforeMaxEnergyRatio: 'the ratio between the pitch energy after the pitch maximum to the pitch energy before the pitch maximum'} +* @memberof Essentia +*/ +class AfterMaxToBeforeMaxEnergyRatio { + private algoInstance: any; + constructor() { + this.algoInstance = new wasmBackend.AfterMaxToBeforeMaxEnergyRatio(); } - - /** - * This algorithm implements a IIR all-pass filter of order 1 or 2. Because of its dependence on IIR, IIR's requirements are inherited. Check https://essentia.upf.edu/reference/std_AllPass.html for more details. - * @method - * @param {VectorFloat} signal the input signal - * @param {number} [bandwidth=500] the bandwidth of the filter [Hz] (used only for 2nd-order filters) - * @param {number} [cutoffFrequency=1500] the cutoff frequency for the filter [Hz] - * @param {number} [order=1] the order of the filter - * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] - * @returns {object} {signal: 'the filtered signal'} - * @memberof Essentia - */ - AllPass(signal: any, bandwidth: number=500, cutoffFrequency: number=1500, order: number=1, sampleRate: number=44100) { - return this.algorithms.AllPass(signal, bandwidth, cutoffFrequency, order, sampleRate); + configure() { + this.algoInstance.configure(); } - - /** - * This algorithm creates a wave file in which a given audio signal is mixed with a series of time onsets. The sonification of the onsets can be heard as beeps, or as short white noise pulses if configured to do so. Check https://essentia.upf.edu/reference/std_AudioOnsetsMarker.html for more details. - * @method - * @param {VectorFloat} signal the input signal - * @param {any[]} [onsets=[]] the list of onset locations [s] - * @param {number} [sampleRate=44100] the sampling rate of the output signal [Hz] - * @param {string} [type=beep] the type of sound to be added on the event - * @returns {object} {signal: 'the input signal mixed with bursts at onset locations'} - * @memberof Essentia - */ - AudioOnsetsMarker(signal: any, onsets: any[]=[], sampleRate: number=44100, type: string='beep') { - let veconsets = new this.module.VectorFloat(); + compute(pitch: any) { + return this.algoInstance.compute(pitch); + } +} + +/** +* This algorithm implements a IIR all-pass filter of order 1 or 2. Because of its dependence on IIR, IIR's requirements are inherited. Check https://essentia.upf.edu/reference/std_AllPass.html for more details. +* @class +* @param {VectorFloat} signal the input signal +* @param {number} [bandwidth=500] the bandwidth of the filter [Hz] (used only for 2nd-order filters) +* @param {number} [cutoffFrequency=1500] the cutoff frequency for the filter [Hz] +* @param {number} [order=1] the order of the filter +* @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] +* @returns {object} {signal: 'the filtered signal'} +* @memberof Essentia +*/ +class AllPass { + private algoInstance: any; + constructor(bandwidth: number=500, cutoffFrequency: number=1500, order: number=1, sampleRate: number=44100) { + this.algoInstance = new wasmBackend.AllPass(bandwidth, cutoffFrequency, order, sampleRate); + } + configure(bandwidth: number=500, cutoffFrequency: number=1500, order: number=1, sampleRate: number=44100) { + this.algoInstance.configure(bandwidth, cutoffFrequency, order, sampleRate); + } + compute(signal: any) { + return this.algoInstance.compute(signal); + } +} + +/** +* This algorithm creates a wave file in which a given audio signal is mixed with a series of time onsets. The sonification of the onsets can be heard as beeps, or as short white noise pulses if configured to do so. Check https://essentia.upf.edu/reference/std_AudioOnsetsMarker.html for more details. +* @class +* @param {VectorFloat} signal the input signal +* @param {any[]} [onsets=[]] the list of onset locations [s] +* @param {number} [sampleRate=44100] the sampling rate of the output signal [Hz] +* @param {string} [type=beep] the type of sound to be added on the event +* @returns {object} {signal: 'the input signal mixed with bursts at onset locations'} +* @memberof Essentia +*/ +class AudioOnsetsMarker { + private algoInstance: any; + constructor(onsets: any[]=[], sampleRate: number=44100, type: string='beep') { + let veconsets = new wasmBackend.VectorFloat(); for (var i=0; i[<#/b>]` (i.e. C, C# or C#m are valid chords). Chord names not fitting this convention will throw an exception. Check https://essentia.upf.edu/reference/std_ChordsDescriptors.html for more details. - * @method - * @param {VectorString} chords the chord progression - * @param {string} key the key of the whole song, from A to G - * @param {string} scale the scale of the whole song (major or minor) - * @returns {object} {chordsHistogram: 'the normalized histogram of chords', chordsNumberRate: 'the ratio of different chords from the total number of chords in the progression', chordsChangesRate: 'the rate at which chords change in the progression', chordsKey: 'the most frequent chord of the progression', chordsScale: 'the scale of the most frequent chord of the progression (either 'major' or 'minor')'} - * @memberof Essentia - */ - ChordsDescriptors(chords: any, key: string, scale: string) { - return this.algorithms.ChordsDescriptors(chords, key, scale); + compute(spectrum: any) { + return this.algoInstance.compute(spectrum); } - - /** - * This algorithm estimates chords given an input sequence of harmonic pitch class profiles (HPCPs). It finds the best matching major or minor triad and outputs the result as a string (e.g. A#, Bm, G#m, C). The following note names are used in the output: - "A", "Bb", "B", "C", "C#", "D", "Eb", "E", "F", "F#", "G", "Ab". - Note: - - The algorithm assumes that the sequence of the input HPCP frames has been computed with framesize = 2*hopsize - - The algorithm estimates a sequence of chord values corresponding to the input HPCP frames (one chord value for each frame, estimated using a temporal window of HPCPs centered at that frame). Check https://essentia.upf.edu/reference/std_ChordsDetection.html for more details. - * @method - * @param {VectorVectorFloat} pcp the pitch class profile from which to detect the chord - * @param {number} [hopSize=2048] the hop size with which the input PCPs were computed - * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] - * @param {number} [windowSize=2] the size of the window on which to estimate the chords [s] - * @returns {object} {chords: 'the resulting chords, from A to G', strength: 'the strength of the chord'} - * @memberof Essentia - */ - ChordsDetection(pcp: any, hopSize: number=2048, sampleRate: number=44100, windowSize: number=2) { - return this.algorithms.ChordsDetection(pcp, hopSize, sampleRate, windowSize); +} + +/** +* This algorithm estimates the beat positions given an input signal. It computes 'complex spectral difference' onset detection function and utilizes the beat tracking algorithm (TempoTapDegara) to extract beats [1]. The algorithm works with the optimized settings of 2048/1024 frame/hop size for the computation of the detection function, with its posterior x2 resampling.) While it has a lower accuracy than BeatTrackerMultifeature (see the evaluation results in [2]), its computational speed is significantly higher, which makes reasonable to apply this algorithm for batch processings of large amounts of audio signals. Check https://essentia.upf.edu/reference/std_BeatTrackerDegara.html for more details. +* @class +* @param {VectorFloat} signal the audio input signal +* @param {number} [maxTempo=208] the fastest tempo to detect [bpm] +* @param {number} [minTempo=40] the slowest tempo to detect [bpm] +* @returns {object} {ticks: ' the estimated tick locations [s]'} +* @memberof Essentia +*/ +class BeatTrackerDegara { + private algoInstance: any; + constructor(maxTempo: number=208, minTempo: number=40) { + this.algoInstance = new wasmBackend.BeatTrackerDegara(maxTempo, minTempo); } - - /** - * This algorithm estimates chords using pitch profile classes on segments between beats. It is similar to ChordsDetection algorithm, but the chords are estimated on audio segments between each pair of consecutive beats. For each segment the estimation is done based on a chroma (HPCP) vector characterizing it, which can be computed by two methods: - - 'interbeat_median', each resulting chroma vector component is a median of all the component values in the segment - - 'starting_beat', chroma vector is sampled from the start of the segment (that is, its starting beat position) using its first frame. It makes sense if chroma is preliminary smoothed. Check https://essentia.upf.edu/reference/std_ChordsDetectionBeats.html for more details. - * @method - * @param {VectorVectorFloat} pcp the pitch class profile from which to detect the chord - * @param {VectorFloat} ticks the list of beat positions (in seconds). One chord will be outputted for each segment between two adjacent ticks. If number of ticks is smaller than 2, exception will be thrown. Those ticks that exceeded the pcp time length will be ignored. - * @param {string} [chromaPick=interbeat_median] method of calculating singleton chroma for interbeat interval - * @param {number} [hopSize=2048] the hop size with which the input PCPs were computed - * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] - * @returns {object} {chords: 'the resulting chords, from A to G', strength: 'the strength of the chords'} - * @memberof Essentia - */ - ChordsDetectionBeats(pcp: any, ticks: any, chromaPick: string='interbeat_median', hopSize: number=2048, sampleRate: number=44100) { - return this.algorithms.ChordsDetectionBeats(pcp, ticks, chromaPick, hopSize, sampleRate); + configure(maxTempo: number=208, minTempo: number=40) { + this.algoInstance.configure(maxTempo, minTempo); } - - /** - * This algorithm computes a binary cross similarity matrix from two chromagam feature vectors of a query and reference song. Check https://essentia.upf.edu/reference/std_ChromaCrossSimilarity.html for more details. - * @method - * @param {VectorVectorFloat} queryFeature frame-wise chromagram of the query song (e.g., a HPCP) - * @param {VectorVectorFloat} referenceFeature frame-wise chromagram of the reference song (e.g., a HPCP) - * @param {number} [binarizePercentile=0.095] maximum percent of distance values to consider as similar in each row and each column - * @param {number} [frameStackSize=9] number of input frames to stack together and treat as a feature vector for similarity computation. Choose 'frameStackSize=1' to use the original input frames without stacking - * @param {number} [frameStackStride=1] stride size to form a stack of frames (e.g., 'frameStackStride'=1 to use consecutive frames; 'frameStackStride'=2 for using every second frame) - * @param {number} [noti=12] number of circular shifts to be checked for Optimal Transposition Index [1] - * @param {boolean} [oti=true] whether to transpose the key of the reference song to the query song by Optimal Transposition Index [1] - * @param {boolean} [otiBinary=false] whether to use the OTI-based chroma binary similarity method [3] - * @param {boolean} [streaming=false] whether to accumulate the input 'queryFeature' in the euclidean similarity matrix calculation on each compute() method call - * @returns {object} {csm: '2D binary cross-similarity matrix of the query and reference features'} - * @memberof Essentia - */ - ChromaCrossSimilarity(queryFeature: any, referenceFeature: any, binarizePercentile: number=0.095, frameStackSize: number=9, frameStackStride: number=1, noti: number=12, oti: boolean=true, otiBinary: boolean=false, streaming: boolean=false) { - return this.algorithms.ChromaCrossSimilarity(queryFeature, referenceFeature, binarizePercentile, frameStackSize, frameStackStride, noti, oti, otiBinary, streaming); + compute(signal: any) { + return this.algoInstance.compute(signal); } - - /** - * This algorithm computes the Constant-Q chromagram using FFT. See ConstantQ algorithm for more details. - Check https://essentia.upf.edu/reference/std_Chromagram.html for more details. - * @method - * @param {VectorFloat} frame the input audio frame - * @param {number} [binsPerOctave=12] number of bins per octave - * @param {number} [minFrequency=32.7] minimum frequency [Hz] - * @param {number} [minimumKernelSize=4] minimum size allowed for frequency kernels - * @param {string} [normalizeType=unit_max] normalize type - * @param {number} [numberBins=84] number of frequency bins, starting at minFrequency - * @param {number} [sampleRate=44100] FFT sampling rate [Hz] - * @param {number} [scale=1] filters scale. Larger values use longer windows - * @param {number} [threshold=0.01] bins whose magnitude is below this quantile are discarded - * @param {string} [windowType=hann] the window type - * @param {boolean} [zeroPhase=true] a boolean value that enables zero-phase windowing. Input audio frames should be windowed with the same phase mode - * @returns {object} {chromagram: 'the magnitude constant-Q chromagram'} - * @memberof Essentia - */ - Chromagram(frame: any, binsPerOctave: number=12, minFrequency: number=32.7, minimumKernelSize: number=4, normalizeType: string='unit_max', numberBins: number=84, sampleRate: number=44100, scale: number=1, threshold: number=0.01, windowType: string='hann', zeroPhase: boolean=true) { - return this.algorithms.Chromagram(frame, binsPerOctave, minFrequency, minimumKernelSize, normalizeType, numberBins, sampleRate, scale, threshold, windowType, zeroPhase); +} + +/** +* This algorithm estimates the beat positions given an input signal. It computes a number of onset detection functions and estimates beat location candidates from them using TempoTapDegara algorithm. Thereafter the best candidates are selected using TempoTapMaxAgreement. The employed detection functions, and the optimal frame/hop sizes used for their computation are: + - complex spectral difference (see 'complex' method in OnsetDetection algorithm, 2048/1024 with posterior x2 upsample or the detection function) + - energy flux (see 'rms' method in OnsetDetection algorithm, the same settings) + - spectral flux in Mel-frequency bands (see 'melflux' method in OnsetDetection algorithm, the same settings) + - beat emphasis function (see 'beat_emphasis' method in OnsetDetectionGlobal algorithm, 2048/512) + - spectral flux between histogrammed spectrum frames, measured by the modified information gain (see 'infogain' method in OnsetDetectionGlobal algorithm, 2048/512) Check https://essentia.upf.edu/reference/std_BeatTrackerMultiFeature.html for more details. +* @class +* @param {VectorFloat} signal the audio input signal +* @param {number} [maxTempo=208] the fastest tempo to detect [bpm] +* @param {number} [minTempo=40] the slowest tempo to detect [bpm] +* @returns {object} {ticks: ' the estimated tick locations [s]', confidence: 'confidence of the beat tracker [0, 5.32]'} +* @memberof Essentia +*/ +class BeatTrackerMultiFeature { + private algoInstance: any; + constructor(maxTempo: number=208, minTempo: number=40) { + this.algoInstance = new wasmBackend.BeatTrackerMultiFeature(maxTempo, minTempo); } - - /** - * This algorithm detects the locations of impulsive noises (clicks and pops) on the input audio frame. It relies on LPC coefficients to inverse-filter the audio in order to attenuate the stationary part and enhance the prediction error (or excitation noise)[1]. After this, a matched filter is used to further enhance the impulsive peaks. The detection threshold is obtained from a robust estimate of the excitation noise power [2] plus a parametric gain value. Check https://essentia.upf.edu/reference/std_ClickDetector.html for more details. - * @method - * @param {VectorFloat} frame the input frame (must be non-empty) - * @param {number} [detectionThreshold=30] 'detectionThreshold' the threshold is based on the instant power of the noisy excitation signal plus detectionThreshold dBs - * @param {number} [frameSize=512] the expected size of the input audio signal (this is an optional parameter to optimize memory allocation) - * @param {number} [hopSize=256] hop size used for the analysis. This parameter must be set correctly as it cannot be obtained from the input data - * @param {number} [order=12] scalar giving the number of LPCs to use - * @param {number} [powerEstimationThreshold=10] the noisy excitation is clipped to 'powerEstimationThreshold' times its median. - * @param {number} [sampleRate=44100] sample rate used for the analysis - * @param {number} [silenceThreshold=-50] threshold to skip silent frames - * @returns {object} {starts: 'starting indexes of the clicks', ends: 'ending indexes of the clicks'} - * @memberof Essentia - */ - ClickDetector(frame: any, detectionThreshold: number=30, frameSize: number=512, hopSize: number=256, order: number=12, powerEstimationThreshold: number=10, sampleRate: number=44100, silenceThreshold: number=-50) { - return this.algorithms.ClickDetector(frame, detectionThreshold, frameSize, hopSize, order, powerEstimationThreshold, sampleRate, silenceThreshold); + configure(maxTempo: number=208, minTempo: number=40) { + this.algoInstance.configure(maxTempo, minTempo); } - - /** - * This algorithm clips the input signal to fit its values into a specified interval. Check https://essentia.upf.edu/reference/std_Clipper.html for more details. - * @method - * @param {VectorFloat} signal the input signal - * @param {number} [max=1] the maximum value above which the signal will be clipped - * @param {number} [min=-1] the minimum value below which the signal will be clipped - * @returns {object} {signal: 'the output signal with the added noise'} - * @memberof Essentia - */ - Clipper(signal: any, max: number=1, min: number=-1) { - return this.algorithms.Clipper(signal, max, min); + compute(signal: any) { + return this.algoInstance.compute(signal); } - - /** - * This algorithm computes a cover song similiarity measure from a binary cross similarity matrix input between two chroma vectors of a query and reference song using various alignment constraints of smith-waterman local-alignment algorithm. Check https://essentia.upf.edu/reference/std_CoverSongSimilarity.html for more details. - * @method - * @param {VectorVectorFloat} inputArray a 2D binary cross-similarity matrix between two audio chroma vectors (query vs reference song) (refer 'ChromaCrossSimilarity' algorithm'). - * @param {string} [alignmentType=serra09] choose either one of the given local-alignment constraints for smith-waterman algorithm as described in [2] or [3] respectively. - * @param {number} [disExtension=0.5] penalty for disruption extension - * @param {number} [disOnset=0.5] penalty for disruption onset - * @param {string} [distanceType=asymmetric] choose the type of distance. By default the algorithm outputs a asymmetric distance which is obtained by normalising the maximum score in the alignment score matrix with length of reference song - * @returns {object} {scoreMatrix: 'a 2D smith-waterman alignment score matrix from the input binary cross-similarity matrix', distance: 'cover song similarity distance between the query and reference song from the input similarity matrix. Either 'asymmetric' (as described in [2]) or 'symmetric' (maximum score in the alignment score matrix).'} - * @memberof Essentia - */ - CoverSongSimilarity(inputArray: any, alignmentType: string='serra09', disExtension: number=0.5, disOnset: number=0.5, distanceType: string='asymmetric') { - return this.algorithms.CoverSongSimilarity(inputArray, alignmentType, disExtension, disOnset, distanceType); +} + +/** +* This algorithm filters the loudness matrix given by BeatsLoudness algorithm in order to keep only the most salient beat band representation. +This algorithm has been found to be useful for estimating time signatures. Check https://essentia.upf.edu/reference/std_Beatogram.html for more details. +* @class +* @param {VectorFloat} loudness the loudness at each beat +* @param {VectorVectorFloat} loudnessBandRatio matrix of loudness ratios at each band and beat +* @param {number} [size=16] number of beats for dynamic filtering +* @returns {object} {beatogram: 'filtered matrix loudness'} +* @memberof Essentia +*/ +class Beatogram { + private algoInstance: any; + constructor(size: number=16) { + this.algoInstance = new wasmBackend.Beatogram(size); } - - /** - * This algorithm computes the crest of an array. The crest is defined as the ratio between the maximum value and the arithmetic mean of an array. Typically it is used on the magnitude spectrum. Check https://essentia.upf.edu/reference/std_Crest.html for more details. - * @method - * @param {VectorFloat} array the input array (cannot contain negative values, and must be non-empty) - * @returns {object} {crest: 'the crest of the input array'} - * @memberof Essentia - */ - Crest(array: any) { - return this.algorithms.Crest(array); + configure(size: number=16) { + this.algoInstance.configure(size); } - - /** - * This algorithm computes the cross-correlation vector of two signals. It accepts 2 parameters, minLag and maxLag which define the range of the computation of the innerproduct. Check https://essentia.upf.edu/reference/std_CrossCorrelation.html for more details. - * @method - * @param {VectorFloat} arrayX the first input array - * @param {VectorFloat} arrayY the second input array - * @param {number} [maxLag=1] the maximum lag to be computed between the two vectors - * @param {number} [minLag=0] the minimum lag to be computed between the two vectors - * @returns {object} {crossCorrelation: 'the cross-correlation vector between the two input arrays (its size is equal to maxLag - minLag + 1)'} - * @memberof Essentia - */ - CrossCorrelation(arrayX: any, arrayY: any, maxLag: number=1, minLag: number=0) { - return this.algorithms.CrossCorrelation(arrayX, arrayY, maxLag, minLag); + compute(loudness: any, loudnessBandRatio: any) { + return this.algoInstance.compute(loudness, loudnessBandRatio); } - - /** - * This algorithm computes a euclidean cross-similarity matrix of two sequences of frame features. Similarity values can be optionally binarized Check https://essentia.upf.edu/reference/std_CrossSimilarityMatrix.html for more details. - * @method - * @param {VectorVectorFloat} queryFeature input frame features of the query song (e.g., a chromagram) - * @param {VectorVectorFloat} referenceFeature input frame features of the reference song (e.g., a chromagram) - * @param {boolean} [binarize=false] whether to binarize the euclidean cross-similarity matrix - * @param {number} [binarizePercentile=0.095] maximum percent of distance values to consider as similar in each row and each column - * @param {number} [frameStackSize=1] number of input frames to stack together and treat as a feature vector for similarity computation. Choose 'frameStackSize=1' to use the original input frames without stacking - * @param {number} [frameStackStride=1] stride size to form a stack of frames (e.g., 'frameStackStride'=1 to use consecutive frames; 'frameStackStride'=2 for using every second frame) - * @returns {object} {csm: '2D cross-similarity matrix of two input frame sequences (query vs reference)'} - * @memberof Essentia - */ - CrossSimilarityMatrix(queryFeature: any, referenceFeature: any, binarize: boolean=false, binarizePercentile: number=0.095, frameStackSize: number=1, frameStackStride: number=1) { - return this.algorithms.CrossSimilarityMatrix(queryFeature, referenceFeature, binarize, binarizePercentile, frameStackSize, frameStackStride); +} + +/** +* This algorithm computes the spectrum energy of beats in an audio signal given their positions. The energy is computed both on the whole frequency range and for each of the specified frequency bands. See the SingleBeatLoudness algorithm for a more detailed explanation. Check https://essentia.upf.edu/reference/std_BeatsLoudness.html for more details. +* @class +* @param {VectorFloat} signal the input audio signal +* @param {number} [beatDuration=0.05] the duration of the window in which the beat will be restricted [s] +* @param {number} [beatWindowDuration=0.1] the duration of the window in which to look for the beginning of the beat (centered around the positions in 'beats') [s] +* @param {any[]} [beats=[]] the list of beat positions (each position is in seconds) +* @param {any[]} [frequencyBands=[20, 150, 400, 3200, 7000, 22000]] the list of bands to compute energy ratios [Hz +* @param {number} [sampleRate=44100] the audio sampling rate [Hz] +* @returns {object} {loudness: 'the beat's energy in the whole spectrum', loudnessBandRatio: 'the ratio of the beat's energy on each frequency band'} +* @memberof Essentia +*/ +class BeatsLoudness { + private algoInstance: any; + constructor(beatDuration: number=0.05, beatWindowDuration: number=0.1, beats: any[]=[], frequencyBands: any[]=[20, 150, 400, 3200, 7000, 22000], sampleRate: number=44100) { + let vecbeats = new wasmBackend.VectorFloat(); + for (var i=0; i[<#/b>]` (i.e. C, C# or C#m are valid chords). Chord names not fitting this convention will throw an exception. Check https://essentia.upf.edu/reference/std_ChordsDescriptors.html for more details. +* @class +* @param {VectorString} chords the chord progression +* @param {string} key the key of the whole song, from A to G +* @param {string} scale the scale of the whole song (major or minor) +* @returns {object} {chordsHistogram: 'the normalized histogram of chords', chordsNumberRate: 'the ratio of different chords from the total number of chords in the progression', chordsChangesRate: 'the rate at which chords change in the progression', chordsKey: 'the most frequent chord of the progression', chordsScale: 'the scale of the most frequent chord of the progression (either 'major' or 'minor')'} +* @memberof Essentia +*/ +class ChordsDescriptors { + private algoInstance: any; + constructor() { + this.algoInstance = new wasmBackend.ChordsDescriptors(); } - - /** - * This algorithm computes the flatness of an array, which is defined as the ratio between the geometric mean and the arithmetic mean converted to dB scale. Check https://essentia.upf.edu/reference/std_FlatnessDB.html for more details. - * @method - * @param {VectorFloat} array the input array - * @returns {object} {flatnessDB: 'the flatness dB'} - * @memberof Essentia - */ - FlatnessDB(array: any) { - return this.algorithms.FlatnessDB(array); + configure() { + this.algoInstance.configure(); } - - /** - * This algorithm calculates the flatness coefficient of a signal envelope. Check https://essentia.upf.edu/reference/std_FlatnessSFX.html for more details. - * @method - * @param {VectorFloat} envelope the envelope of the signal - * @returns {object} {flatness: 'the flatness coefficient'} - * @memberof Essentia - */ - FlatnessSFX(envelope: any) { - return this.algorithms.FlatnessSFX(envelope); + compute(chords: any, key: string, scale: string) { + return this.algoInstance.compute(chords, key, scale); } - - /** - * This algorithm computes the spectral flux of a spectrum. Flux is defined as the L2-norm [1] or L1-norm [2] of the difference between two consecutive frames of the magnitude spectrum. The frames have to be of the same size in order to yield a meaningful result. The default L2-norm is used more commonly. Check https://essentia.upf.edu/reference/std_Flux.html for more details. - * @method - * @param {VectorFloat} spectrum the input spectrum - * @param {boolean} [halfRectify=false] half-rectify the differences in each spectrum bin - * @param {string} [norm=L2] the norm to use for difference computation - * @returns {object} {flux: 'the spectral flux of the input spectrum'} - * @memberof Essentia - */ - Flux(spectrum: any, halfRectify: boolean=false, norm: string='L2') { - return this.algorithms.Flux(spectrum, halfRectify, norm); +} + +/** +* This algorithm estimates chords given an input sequence of harmonic pitch class profiles (HPCPs). It finds the best matching major or minor triad and outputs the result as a string (e.g. A#, Bm, G#m, C). The following note names are used in the output: +"A", "Bb", "B", "C", "C#", "D", "Eb", "E", "F", "F#", "G", "Ab". +Note: + - The algorithm assumes that the sequence of the input HPCP frames has been computed with framesize = 2*hopsize + - The algorithm estimates a sequence of chord values corresponding to the input HPCP frames (one chord value for each frame, estimated using a temporal window of HPCPs centered at that frame). Check https://essentia.upf.edu/reference/std_ChordsDetection.html for more details. +* @class +* @param {VectorVectorFloat} pcp the pitch class profile from which to detect the chord +* @param {number} [hopSize=2048] the hop size with which the input PCPs were computed +* @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] +* @param {number} [windowSize=2] the size of the window on which to estimate the chords [s] +* @returns {object} {chords: 'the resulting chords, from A to G', strength: 'the strength of the chord'} +* @memberof Essentia +*/ +class ChordsDetection { + private algoInstance: any; + constructor(hopSize: number=2048, sampleRate: number=44100, windowSize: number=2) { + this.algoInstance = new wasmBackend.ChordsDetection(hopSize, sampleRate, windowSize); } - - /** - * This algorithm slices the input buffer into frames. It returns a frame of a constant size and jumps a constant amount of samples forward in the buffer on every compute() call until no more frames can be extracted; empty frame vectors are returned afterwards. Incomplete frames (frames starting before the beginning of the input buffer or going past its end) are zero-padded or dropped according to the "validFrameThresholdRatio" parameter. Check https://essentia.upf.edu/reference/std_FrameCutter.html for more details. - * @method - * @param {VectorFloat} signal the buffer from which to read data - * @param {number} [frameSize=1024] the output frame size - * @param {number} [hopSize=512] the hop size between frames - * @param {boolean} [lastFrameToEndOfFile=false] whether the beginning of the last frame should reach the end of file. Only applicable if startFromZero is true - * @param {boolean} [startFromZero=false] whether to start the first frame at time 0 (centered at frameSize/2) if true, or -frameSize/2 otherwise (zero-centered) - * @param {number} [validFrameThresholdRatio=0] frames smaller than this ratio will be discarded, those larger will be zero-padded to a full frame (i.e. a value of 0 will never discard frames and a value of 1 will only keep frames that are of length 'frameSize') - * @returns {object} {frame: 'the frame to write to'} - * @memberof Essentia - */ - FrameCutter(signal: any, frameSize: number=1024, hopSize: number=512, lastFrameToEndOfFile: boolean=false, startFromZero: boolean=false, validFrameThresholdRatio: number=0) { - return this.algorithms.FrameCutter(signal, frameSize, hopSize, lastFrameToEndOfFile, startFromZero, validFrameThresholdRatio); + configure(hopSize: number=2048, sampleRate: number=44100, windowSize: number=2) { + this.algoInstance.configure(hopSize, sampleRate, windowSize); } - - /** - * This algorithm converts a sequence of input audio signal frames into a sequence of audio samples. Check https://essentia.upf.edu/reference/std_FrameToReal.html for more details. - * @method - * @param {VectorFloat} signal the input audio frame - * @param {number} [frameSize=2048] the frame size for computing the overlap-add process - * @param {number} [hopSize=128] the hop size with which the overlap-add function is computed - * @returns {object} {signal: 'the output audio samples'} - * @memberof Essentia - */ - FrameToReal(signal: any, frameSize: number=2048, hopSize: number=128) { - return this.algorithms.FrameToReal(signal, frameSize, hopSize); + compute(pcp: any) { + return this.algoInstance.compute(pcp); } - - /** - * This algorithm computes energy in rectangular frequency bands of a spectrum. The bands are non-overlapping. For each band the power-spectrum (mag-squared) is summed. Check https://essentia.upf.edu/reference/std_FrequencyBands.html for more details. - * @method - * @param {VectorFloat} spectrum the input spectrum (must be greater than size one) - * @param {any[]} [frequencyBands=[0, 50, 100, 150, 200, 300, 400, 510, 630, 770, 920, 1080, 1270, 1480, 1720, 2000, 2320, 2700, 3150, 3700, 4400, 5300, 6400, 7700, 9500, 12000, 15500, 20500, 27000]] list of frequency ranges in to which the spectrum is divided (these must be in ascending order and connot contain duplicates) - * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] - * @returns {object} {bands: 'the energy in each band'} - * @memberof Essentia - */ - FrequencyBands(spectrum: any, frequencyBands: any[]=[0, 50, 100, 150, 200, 300, 400, 510, 630, 770, 920, 1080, 1270, 1480, 1720, 2000, 2320, 2700, 3150, 3700, 4400, 5300, 6400, 7700, 9500, 12000, 15500, 20500, 27000], sampleRate: number=44100) { - let vecfrequencyBands = new this.module.VectorFloat(); - for (var i=0; i1). Check https://essentia.upf.edu/reference/std_HPCP.html for more details. - * @method - * @param {VectorFloat} frequencies the frequencies of the spectral peaks [Hz] - * @param {VectorFloat} magnitudes the magnitudes of the spectral peaks - * @param {boolean} [bandPreset=true] enables whether to use a band preset - * @param {number} [bandSplitFrequency=500] the split frequency for low and high bands, not used if bandPreset is false [Hz] - * @param {number} [harmonics=0] number of harmonics for frequency contribution, 0 indicates exclusive fundamental frequency contribution - * @param {number} [maxFrequency=5000] the maximum frequency that contributes to the HPCP [Hz] (the difference between the max and split frequencies must not be less than 200.0 Hz) - * @param {boolean} [maxShifted=false] whether to shift the HPCP vector so that the maximum peak is at index 0 - * @param {number} [minFrequency=40] the minimum frequency that contributes to the HPCP [Hz] (the difference between the min and split frequencies must not be less than 200.0 Hz) - * @param {boolean} [nonLinear=false] apply non-linear post-processing to the output (use with normalized='unitMax'). Boosts values close to 1, decreases values close to 0. - * @param {string} [normalized=unitMax] whether to normalize the HPCP vector - * @param {number} [referenceFrequency=440] the reference frequency for semitone index calculation, corresponding to A3 [Hz] - * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] - * @param {number} [size=12] the size of the output HPCP (must be a positive nonzero multiple of 12) - * @param {string} [weightType=squaredCosine] type of weighting function for determining frequency contribution - * @param {number} [windowSize=1] the size, in semitones, of the window used for the weighting - * @returns {object} {hpcp: 'the resulting harmonic pitch class profile'} - * @memberof Essentia - */ - HPCP(frequencies: any, magnitudes: any, bandPreset: boolean=true, bandSplitFrequency: number=500, harmonics: number=0, maxFrequency: number=5000, maxShifted: boolean=false, minFrequency: number=40, nonLinear: boolean=false, normalized: string='unitMax', referenceFrequency: number=440, sampleRate: number=44100, size: number=12, weightType: string='squaredCosine', windowSize: number=1) { - return this.algorithms.HPCP(frequencies, magnitudes, bandPreset, bandSplitFrequency, harmonics, maxFrequency, maxShifted, minFrequency, nonLinear, normalized, referenceFrequency, sampleRate, size, weightType, windowSize); + compute(queryFeature: any, referenceFeature: any) { + return this.algoInstance.compute(queryFeature, referenceFeature); } - - /** - * This algorithm extracts bpms that are harmonically related to the tempo given by the 'bpm' parameter. - The algorithm assumes a certain bpm is harmonically related to parameter bpm, when the greatest common divisor between both bpms is greater than threshold. - The 'tolerance' parameter is needed in order to consider if two bpms are related. For instance, 120, 122 and 236 may be related or not depending on how much tolerance is given Check https://essentia.upf.edu/reference/std_HarmonicBpm.html for more details. - * @method - * @param {VectorFloat} bpms list of bpm candidates - * @param {number} [bpm=60] the bpm used to find its harmonics - * @param {number} [threshold=20] bpm threshold below which greatest common divisors are discarded - * @param {number} [tolerance=5] percentage tolerance to consider two bpms are equal or equal to a harmonic - * @returns {object} {harmonicBpms: 'a list of bpms which are harmonically related to the bpm parameter '} - * @memberof Essentia - */ - HarmonicBpm(bpms: any, bpm: number=60, threshold: number=20, tolerance: number=5) { - return this.algorithms.HarmonicBpm(bpms, bpm, threshold, tolerance); +} + +/** +* This algorithm computes the Constant-Q chromagram using FFT. See ConstantQ algorithm for more details. + Check https://essentia.upf.edu/reference/std_Chromagram.html for more details. +* @class +* @param {VectorFloat} frame the input audio frame +* @param {number} [binsPerOctave=12] number of bins per octave +* @param {number} [minFrequency=32.7] minimum frequency [Hz] +* @param {number} [minimumKernelSize=4] minimum size allowed for frequency kernels +* @param {string} [normalizeType=unit_max] normalize type +* @param {number} [numberBins=84] number of frequency bins, starting at minFrequency +* @param {number} [sampleRate=44100] FFT sampling rate [Hz] +* @param {number} [scale=1] filters scale. Larger values use longer windows +* @param {number} [threshold=0.01] bins whose magnitude is below this quantile are discarded +* @param {string} [windowType=hann] the window type +* @param {boolean} [zeroPhase=true] a boolean value that enables zero-phase windowing. Input audio frames should be windowed with the same phase mode +* @returns {object} {chromagram: 'the magnitude constant-Q chromagram'} +* @memberof Essentia +*/ +class Chromagram { + private algoInstance: any; + constructor(binsPerOctave: number=12, minFrequency: number=32.7, minimumKernelSize: number=4, normalizeType: string='unit_max', numberBins: number=84, sampleRate: number=44100, scale: number=1, threshold: number=0.01, windowType: string='hann', zeroPhase: boolean=true) { + this.algoInstance = new wasmBackend.Chromagram(binsPerOctave, minFrequency, minimumKernelSize, normalizeType, numberBins, sampleRate, scale, threshold, windowType, zeroPhase); } - - /** - * This algorithm finds the harmonic peaks of a signal given its spectral peaks and its fundamental frequency. - Note: - - "tolerance" parameter defines the allowed fixed deviation from ideal harmonics, being a percentage over the F0. For example: if the F0 is 100Hz you may decide to allow a deviation of 20%, that is a fixed deviation of 20Hz; for the harmonic series it is: [180-220], [280-320], [380-420], etc. - - If "pitch" is zero, it means its value is unknown, or the sound is unpitched, and in that case the HarmonicPeaks algorithm returns an empty vector. - - The output frequency and magnitude vectors are of size "maxHarmonics". If a particular harmonic was not found among spectral peaks, its ideal frequency value is output together with 0 magnitude. - This algorithm is intended to receive its "frequencies" and "magnitudes" inputs from the SpectralPeaks algorithm. - - When input vectors differ in size or are empty, an exception is thrown. Input vectors must be ordered by ascending frequency excluding DC components and not contain duplicates, otherwise an exception is thrown. Check https://essentia.upf.edu/reference/std_HarmonicPeaks.html for more details. - * @method - * @param {VectorFloat} frequencies the frequencies of the spectral peaks [Hz] (ascending order) - * @param {VectorFloat} magnitudes the magnitudes of the spectral peaks (ascending frequency order) - * @param {number} pitch an estimate of the fundamental frequency of the signal [Hz] - * @param {number} [maxHarmonics=20] the number of harmonics to return including F0 - * @param {number} [tolerance=0.2] the allowed ratio deviation from ideal harmonics - * @returns {object} {harmonicFrequencies: 'the frequencies of harmonic peaks [Hz]', harmonicMagnitudes: 'the magnitudes of harmonic peaks'} - * @memberof Essentia - */ - HarmonicPeaks(frequencies: any, magnitudes: any, pitch: number, maxHarmonics: number=20, tolerance: number=0.2) { - return this.algorithms.HarmonicPeaks(frequencies, magnitudes, pitch, maxHarmonics, tolerance); + configure(binsPerOctave: number=12, minFrequency: number=32.7, minimumKernelSize: number=4, normalizeType: string='unit_max', numberBins: number=84, sampleRate: number=44100, scale: number=1, threshold: number=0.01, windowType: string='hann', zeroPhase: boolean=true) { + this.algoInstance.configure(binsPerOctave, minFrequency, minimumKernelSize, normalizeType, numberBins, sampleRate, scale, threshold, windowType, zeroPhase); } - - /** - * This algorithm implements a 1st order IIR high-pass filter. Because of its dependence on IIR, IIR's requirements are inherited. Check https://essentia.upf.edu/reference/std_HighPass.html for more details. - * @method - * @param {VectorFloat} signal the input audio signal - * @param {number} [cutoffFrequency=1500] the cutoff frequency for the filter [Hz] - * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] - * @returns {object} {signal: 'the filtered signal'} - * @memberof Essentia - */ - HighPass(signal: any, cutoffFrequency: number=1500, sampleRate: number=44100) { - return this.algorithms.HighPass(signal, cutoffFrequency, sampleRate); + compute(frame: any) { + return this.algoInstance.compute(frame); } - - /** - * This algorithm computes high-resolution chroma features from an HPCP vector. The vector's size must be a multiple of 12 and it is recommended that it be larger than 120. In otherwords, the HPCP's resolution should be 10 Cents or more. - The high-resolution features being computed are: Check https://essentia.upf.edu/reference/std_HighResolutionFeatures.html for more details. - * @method - * @param {VectorFloat} hpcp the HPCPs, preferably of size >= 120 - * @param {number} [maxPeaks=24] maximum number of HPCP peaks to consider when calculating outputs - * @returns {object} {equalTemperedDeviation: 'measure of the deviation of HPCP local maxima with respect to equal-tempered bins', nonTemperedEnergyRatio: 'ratio between the energy on non-tempered bins and the total energy', nonTemperedPeaksEnergyRatio: 'ratio between the energy on non-tempered peaks and the total energy'} - * @memberof Essentia - */ - HighResolutionFeatures(hpcp: any, maxPeaks: number=24) { - return this.algorithms.HighResolutionFeatures(hpcp, maxPeaks); +} + +/** +* This algorithm detects the locations of impulsive noises (clicks and pops) on the input audio frame. It relies on LPC coefficients to inverse-filter the audio in order to attenuate the stationary part and enhance the prediction error (or excitation noise)[1]. After this, a matched filter is used to further enhance the impulsive peaks. The detection threshold is obtained from a robust estimate of the excitation noise power [2] plus a parametric gain value. Check https://essentia.upf.edu/reference/std_ClickDetector.html for more details. +* @class +* @param {VectorFloat} frame the input frame (must be non-empty) +* @param {number} [detectionThreshold=30] 'detectionThreshold' the threshold is based on the instant power of the noisy excitation signal plus detectionThreshold dBs +* @param {number} [frameSize=512] the expected size of the input audio signal (this is an optional parameter to optimize memory allocation) +* @param {number} [hopSize=256] hop size used for the analysis. This parameter must be set correctly as it cannot be obtained from the input data +* @param {number} [order=12] scalar giving the number of LPCs to use +* @param {number} [powerEstimationThreshold=10] the noisy excitation is clipped to 'powerEstimationThreshold' times its median. +* @param {number} [sampleRate=44100] sample rate used for the analysis +* @param {number} [silenceThreshold=-50] threshold to skip silent frames +* @returns {object} {starts: 'starting indexes of the clicks', ends: 'ending indexes of the clicks'} +* @memberof Essentia +*/ +class ClickDetector { + private algoInstance: any; + constructor(detectionThreshold: number=30, frameSize: number=512, hopSize: number=256, order: number=12, powerEstimationThreshold: number=10, sampleRate: number=44100, silenceThreshold: number=-50) { + this.algoInstance = new wasmBackend.ClickDetector(detectionThreshold, frameSize, hopSize, order, powerEstimationThreshold, sampleRate, silenceThreshold); } - - /** - * This algorithm computes a histogram. Values outside the range are ignored Check https://essentia.upf.edu/reference/std_Histogram.html for more details. - * @method - * @param {VectorFloat} array the input array - * @param {number} [maxValue=1] the max value of the histogram - * @param {number} [minValue=0] the min value of the histogram - * @param {string} [normalize=none] the normalization setting. - * @param {number} [numberBins=10] the number of bins - * @returns {object} {histogram: 'the values in the equally-spaced bins', binEdges: 'the edges of the equally-spaced bins. Size is _histogram.size() + 1'} - * @memberof Essentia - */ - Histogram(array: any, maxValue: number=1, minValue: number=0, normalize: string='none', numberBins: number=10) { - return this.algorithms.Histogram(array, maxValue, minValue, normalize, numberBins); + configure(detectionThreshold: number=30, frameSize: number=512, hopSize: number=256, order: number=12, powerEstimationThreshold: number=10, sampleRate: number=44100, silenceThreshold: number=-50) { + this.algoInstance.configure(detectionThreshold, frameSize, hopSize, order, powerEstimationThreshold, sampleRate, silenceThreshold); } - - /** - * This algorithm computes the harmonic plus residual model analysis. Check https://essentia.upf.edu/reference/std_HprModelAnal.html for more details. - * @method - * @param {VectorFloat} frame the input frame - * @param {number} pitch external pitch input [Hz]. - * @param {number} [fftSize=2048] the size of the internal FFT size (full spectrum size) - * @param {number} [freqDevOffset=20] minimum frequency deviation at 0Hz - * @param {number} [freqDevSlope=0.01] slope increase of minimum frequency deviation - * @param {number} [harmDevSlope=0.01] slope increase of minimum frequency deviation - * @param {number} [hopSize=512] the hop size between frames - * @param {number} [magnitudeThreshold=0] peaks below this given threshold are not outputted - * @param {number} [maxFrequency=5000] the maximum frequency of the range to evaluate [Hz] - * @param {number} [maxPeaks=100] the maximum number of returned peaks - * @param {number} [maxnSines=100] maximum number of sines per frame - * @param {number} [minFrequency=20] the minimum frequency of the range to evaluate [Hz] - * @param {number} [nHarmonics=100] maximum number of harmonics per frame - * @param {string} [orderBy=frequency] the ordering type of the outputted peaks (ascending by frequency or descending by magnitude) - * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] - * @param {number} [stocf=0.2] decimation factor used for the stochastic approximation - * @returns {object} {frequencies: 'the frequencies of the sinusoidal peaks [Hz]', magnitudes: 'the magnitudes of the sinusoidal peaks', phases: 'the phases of the sinusoidal peaks', res: 'output residual frame'} - * @memberof Essentia - */ - HprModelAnal(frame: any, pitch: number, fftSize: number=2048, freqDevOffset: number=20, freqDevSlope: number=0.01, harmDevSlope: number=0.01, hopSize: number=512, magnitudeThreshold: number=0, maxFrequency: number=5000, maxPeaks: number=100, maxnSines: number=100, minFrequency: number=20, nHarmonics: number=100, orderBy: string='frequency', sampleRate: number=44100, stocf: number=0.2) { - return this.algorithms.HprModelAnal(frame, pitch, fftSize, freqDevOffset, freqDevSlope, harmDevSlope, hopSize, magnitudeThreshold, maxFrequency, maxPeaks, maxnSines, minFrequency, nHarmonics, orderBy, sampleRate, stocf); + compute(frame: any) { + return this.algoInstance.compute(frame); } - - /** - * This algorithm computes the harmonic plus stochastic model analysis. Check https://essentia.upf.edu/reference/std_HpsModelAnal.html for more details. - * @method - * @param {VectorFloat} frame the input frame - * @param {number} pitch external pitch input [Hz]. - * @param {number} [fftSize=2048] the size of the internal FFT size (full spectrum size) - * @param {number} [freqDevOffset=20] minimum frequency deviation at 0Hz - * @param {number} [freqDevSlope=0.01] slope increase of minimum frequency deviation - * @param {number} [harmDevSlope=0.01] slope increase of minimum frequency deviation - * @param {number} [hopSize=512] the hop size between frames - * @param {number} [magnitudeThreshold=0] peaks below this given threshold are not outputted - * @param {number} [maxFrequency=5000] the maximum frequency of the range to evaluate [Hz] - * @param {number} [maxPeaks=100] the maximum number of returned peaks - * @param {number} [maxnSines=100] maximum number of sines per frame - * @param {number} [minFrequency=20] the minimum frequency of the range to evaluate [Hz] - * @param {number} [nHarmonics=100] maximum number of harmonics per frame - * @param {string} [orderBy=frequency] the ordering type of the outputted peaks (ascending by frequency or descending by magnitude) - * @param {number} [sampleRate=44100] the sampling rate of the audio signal [Hz] - * @param {number} [stocf=0.2] decimation factor used for the stochastic approximation - * @returns {object} {frequencies: 'the frequencies of the sinusoidal peaks [Hz]', magnitudes: 'the magnitudes of the sinusoidal peaks', phases: 'the phases of the sinusoidal peaks', stocenv: 'the stochastic envelope'} - * @memberof Essentia - */ - HpsModelAnal(frame: any, pitch: number, fftSize: number=2048, freqDevOffset: number=20, freqDevSlope: number=0.01, harmDevSlope: number=0.01, hopSize: number=512, magnitudeThreshold: number=0, maxFrequency: number=5000, maxPeaks: number=100, maxnSines: number=100, minFrequency: number=20, nHarmonics: number=100, orderBy: string='frequency', sampleRate: number=44100, stocf: number=0.2) { - return this.algorithms.HpsModelAnal(frame, pitch, fftSize, freqDevOffset, freqDevSlope, harmDevSlope, hopSize, magnitudeThreshold, maxFrequency, maxPeaks, maxnSines, minFrequency, nHarmonics, orderBy, sampleRate, stocf); +} + +/** +* This algorithm clips the input signal to fit its values into a specified interval. Check https://essentia.upf.edu/reference/std_Clipper.html for more details. +* @class +* @param {VectorFloat} signal the input signal +* @param {number} [max=1] the maximum value above which the signal will be clipped +* @param {number} [min=-1] the minimum value below which the signal will be clipped +* @returns {object} {signal: 'the output signal with the added noise'} +* @memberof Essentia +*/ +class Clipper { + private algoInstance: any; + constructor(max: number=1, min: number=-1) { + this.algoInstance = new wasmBackend.Clipper(max, min); } - - /** - * This algorithm computes the Inverse Discrete Cosine Transform of an array. - It can be configured to perform the inverse DCT-II form, with the 1/sqrt(2) scaling factor for the first coefficient or the inverse DCT-III form based on the HTK implementation. Check https://essentia.upf.edu/reference/std_IDCT.html for more details. - * @method - * @param {VectorFloat} dct the discrete cosine transform - * @param {number} [dctType=2] the DCT type - * @param {number} [inputSize=10] the size of the input array - * @param {number} [liftering=0] the liftering coefficient. Use '0' to bypass it - * @param {number} [outputSize=10] the number of output coefficients - * @returns {object} {idct: 'the inverse cosine transform of the input array'} - * @memberof Essentia - */ - IDCT(dct: any, dctType: number=2, inputSize: number=10, liftering: number=0, outputSize: number=10) { - return this.algorithms.IDCT(dct, dctType, inputSize, liftering, outputSize); + configure(max: number=1, min: number=-1) { + this.algoInstance.configure(max, min); } - - /** - * This algorithm implements a standard IIR filter. It filters the data in the input vector with the filter described by parameter vectors 'numerator' and 'denominator' to create the output filtered vector. In the litterature, the numerator is often referred to as the 'B' coefficients and the denominator as the 'A' coefficients. Check https://essentia.upf.edu/reference/std_IIR.html for more details. - * @method - * @param {VectorFloat} signal the input signal - * @param {any[]} [denominator=[1]] the list of coefficients of the denominator. Often referred to as the A coefficient vector. - * @param {any[]} [numerator=[1]] the list of coefficients of the numerator. Often referred to as the B coefficient vector. - * @returns {object} {signal: 'the filtered signal'} - * @memberof Essentia - */ - IIR(signal: any, denominator: any[]=[1], numerator: any[]=[1]) { - let vecdenominator = new this.module.VectorFloat(); - for (var i=0; i to multiplex - * @returns {object} {data: 'the frame containing the input values and/or input frames'} - * @memberof Essentia - */ - Multiplexer(numberRealInputs: number=0, numberVectorRealInputs: number=0) { - return this.algorithms.Multiplexer(numberRealInputs, numberVectorRealInputs); + compute(envelope: any) { + return this.algoInstance.compute(envelope); } - - /** - * This algorithm extracts treble and bass chromagrams from a sequence of log-frequency spectrum frames. - On this representation, two processing steps are performed: - -tuning, after which each centre bin (i.e. bin 2, 5, 8, ...) corresponds to a semitone, even if the tuning of the piece deviates from 440 Hz standard pitch. - -running standardisation: subtraction of the running mean, division by the running standard deviation. This has a spectral whitening effect. - This code is ported from NNLS Chroma [1, 2]. To achieve similar results follow this processing chain: - frame slicing with sample rate = 44100, frame size = 16384, hop size = 2048 -> Windowing with Hann and no normalization -> Spectrum -> LogSpectrum. Check https://essentia.upf.edu/reference/std_NNLSChroma.html for more details. - * @method - * @param {VectorVectorFloat} logSpectrogram log spectrum frames - * @param {VectorFloat} meanTuning mean tuning frames - * @param {VectorFloat} localTuning local tuning frames - * @param {string} [chromaNormalization=none] determines whether or how the chromagrams are normalised - * @param {number} [frameSize=1025] the input frame size of the spectrum vector - * @param {number} [sampleRate=44100] the input sample rate - * @param {number} [spectralShape=0.7] the shape of the notes in the NNLS dictionary - * @param {number} [spectralWhitening=1] determines how much the log-frequency spectrum is whitened - * @param {string} [tuningMode=global] local uses a local average for tuning, global uses all audio frames. Local tuning is only advisable when the tuning is likely to change over the audio - * @param {boolean} [useNNLS=true] toggle between NNLS approximate transcription and linear spectral mapping - * @returns {object} {tunedLogfreqSpectrum: 'Log frequency spectrum after tuning', semitoneSpectrum: 'a spectral representation with one bin per semitone', bassChromagram: ' a 12-dimensional chromagram, restricted to the bass range', chromagram: 'a 12-dimensional chromagram, restricted with mid-range emphasis'} - * @memberof Essentia - */ - NNLSChroma(logSpectrogram: any, meanTuning: any, localTuning: any, chromaNormalization: string='none', frameSize: number=1025, sampleRate: number=44100, spectralShape: number=0.7, spectralWhitening: number=1, tuningMode: string='global', useNNLS: boolean=true) { - return this.algorithms.NNLSChroma(logSpectrogram, meanTuning, localTuning, chromaNormalization, frameSize, sampleRate, spectralShape, spectralWhitening, tuningMode, useNNLS); +} + +/** +* This algorithm uses LPC and some heuristics to detect discontinuities in an audio signal. [1]. Check https://essentia.upf.edu/reference/std_DiscontinuityDetector.html for more details. +* @class +* @param {VectorFloat} frame the input frame (must be non-empty) +* @param {number} [detectionThreshold=8] 'detectionThreshold' times the standard deviation plus the median of the frame is used as detection threshold +* @param {number} [energyThreshold=-60] threshold in dB to detect silent subframes +* @param {number} [frameSize=512] the expected size of the input audio signal (this is an optional parameter to optimize memory allocation) +* @param {number} [hopSize=256] hop size used for the analysis. This parameter must be set correctly as it cannot be obtained from the input data +* @param {number} [kernelSize=7] scalar giving the size of the median filter window. Must be odd +* @param {number} [order=3] scalar giving the number of LPCs to use +* @param {number} [silenceThreshold=-50] threshold to skip silent frames +* @param {number} [subFrameSize=32] size of the window used to compute silent subframes +* @returns {object} {discontinuityLocations: 'the index of the detected discontinuities (if any)', discontinuityAmplitudes: 'the peak values of the prediction error for the discontinuities (if any)'} +* @memberof Essentia +*/ +class DiscontinuityDetector { + private algoInstance: any; + constructor(detectionThreshold: number=8, energyThreshold: number=-60, frameSize: number=512, hopSize: number=256, kernelSize: number=7, order: number=3, silenceThreshold: number=-50, subFrameSize: number=32) { + this.algoInstance = new wasmBackend.DiscontinuityDetector(detectionThreshold, energyThreshold, frameSize, hopSize, kernelSize, order, silenceThreshold, subFrameSize); } - - /** - * This algorithm adds noise to an input signal. The average energy of the noise in dB is defined by the level parameter, and is generated using the Mersenne Twister random number generator. Check https://essentia.upf.edu/reference/std_NoiseAdder.html for more details. - * @method - * @param {VectorFloat} signal the input signal - * @param {boolean} [fixSeed=false] if true, 0 is used as the seed for generating random values - * @param {number} [level=-100] power level of the noise generator [dB] - * @returns {object} {signal: 'the output signal with the added noise'} - * @memberof Essentia - */ - NoiseAdder(signal: any, fixSeed: boolean=false, level: number=-100) { - return this.algorithms.NoiseAdder(signal, fixSeed, level); + configure(detectionThreshold: number=8, energyThreshold: number=-60, frameSize: number=512, hopSize: number=256, kernelSize: number=7, order: number=3, silenceThreshold: number=-50, subFrameSize: number=32) { + this.algoInstance.configure(detectionThreshold, energyThreshold, frameSize, hopSize, kernelSize, order, silenceThreshold, subFrameSize); } - - /** - * This algorithm detects noise bursts in the waveform by thresholding the peaks of the second derivative. The threshold is computed using an Exponential Moving Average filter over the RMS of the second derivative of the input frame. Check https://essentia.upf.edu/reference/std_NoiseBurstDetector.html for more details. - * @method - * @param {VectorFloat} frame the input frame (must be non-empty) - * @param {number} [alpha=0.9] alpha coefficient for the Exponential Moving Average threshold estimation. - * @param {number} [silenceThreshold=-50] threshold to skip silent frames - * @param {number} [threshold=8] factor to control the dynamic theshold - * @returns {object} {indexes: 'indexes of the noisy samples'} - * @memberof Essentia - */ - NoiseBurstDetector(frame: any, alpha: number=0.9, silenceThreshold: number=-50, threshold: number=8) { - return this.algorithms.NoiseBurstDetector(frame, alpha, silenceThreshold, threshold); + compute(frame: any) { + return this.algoInstance.compute(frame); } - - /** - * This algorithm computes the "novelty curve" (Grosche & Müller, 2009) onset detection function. The algorithm expects as an input a frame-wise sequence of frequency-bands energies or spectrum magnitudes as originally proposed in [1] (see FrequencyBands and Spectrum algorithms). Novelty in each band (or frequency bin) is computed as a derivative between log-compressed energy (magnitude) values in consequent frames. The overall novelty value is then computed as a weighted sum that can be configured using 'weightCurve' parameter. The resulting novelty curve can be used for beat tracking and onset detection (see BpmHistogram and Onsets). Check https://essentia.upf.edu/reference/std_NoveltyCurve.html for more details. - * @method - * @param {VectorVectorFloat} frequencyBands the frequency bands - * @param {number} [frameRate=344.531] the sampling rate of the input audio - * @param {boolean} [normalize=false] whether to normalize each band's energy - * @param {any[]} [weightCurve=[]] vector containing the weights for each frequency band. Only if weightCurveType==supplied - * @param {string} [weightCurveType=hybrid] the type of weighting to be used for the bands novelty - * @returns {object} {novelty: 'the novelty curve as a single vector'} - * @memberof Essentia - */ - NoveltyCurve(frequencyBands: any, frameRate: number=344.531, normalize: boolean=false, weightCurve: any[]=[], weightCurveType: string='hybrid') { - let vecweightCurve = new this.module.VectorFloat(); - for (var i=0; i