A VST3/LV2/AU plugin and standalone software that analyzes incoming audio and computes a range of audio descriptors, which are sent as OSC (Open Sound Control) messages. These can be used in other software, such as for sound visualization or real-time audio analysis. The Informer is compatible with Windows, Linux, and macOS.
Complementing The Informer, there is also The Case Officer, a Max for Live device that receives data from The Informer so that they can be used as modulation sources within Live. Additionally, there is a C++ header-only library available for integrating the descriptor calculation algorithms into your own software.
Currently, these descriptors have been implemented:
- Kurtosis
- Peak level
- Root mean square
- Skewness
- Variance
- Zero crossing rate
- Centroid
- Crest factor
- Decrease
- Entropy
- Flatness
- Flux
- Irregularity
- Kurtosis
- Peak frequency
- Rolloff (at 85%)
- Skewness
- Slope
- Spread
Please note: when the normalize parameter is enabled, all descriptors are adjusted to ensure they fall within the [0.0, 1.0] range. While some descriptors naturally adhere to this range or have well-defined boundaries (e.g., those typically limited to [0.0, Nyquist frequency]), others —such as kurtosis, skewness, and slope— are adjusted based on empirical observations. As a result, the normalize option is best suited for artistic purposes where exact precision is not essential, focusing instead on preventing values from falling outside the expected range, rather than for detailed sound analysis.
Compiled binaries for Linux, Windows and macOS can be found in the Releases section.
Grab the source with git clone https://github.com/valeriorlandini/theinformer.git --recursive
cd theinformer and then create the necessary build files with:
cmake -S . -B build -G "Visual Studio 17 2022"on Windows (adjust the Visual Studio version if you have an older one.)cmake -S . -B build -G "Unix Makefiles"on Linuxcmake -S . -B build -G Xcodeon Mac
Navigate to the build folder with cd build
Next run cmake --build . --config Release
The compiled binaries can be found inside TheInformer_artefacts/Release (or simply TheInformer_artefacts in Linux) folder.
In Library folder, there is informer.h, a MIT-licensed C++ header-only library to use the plugin algorithms in any application. The library can be used in two ways: by directly calling the provided functions or by creating an instance of the implemented class and then computing and retrieving the descriptors from there.
The library is simply imported with the inclusion of its header:
#include "informer.h"For the first option, there are two namespaces inside the Informer namespace: Amplitude and Frequency. Once you have an iterable container with floating point values (of any type) representing a buffer, you can compute the amplitude descriptors according to the following example:
std::vector<double> myBuffer = /* your buffer */
auto rms = Informer::Amplitude::rms(myBuffer);For descriptors like kurtosis and skewness, which uses the mean and the variance, these values can be passed as optional arguments or, if not provided, they are computed by the function. For frequency descriptors, the functions expect an iterable container with floating point values representing the magnitudes of each bin obtained from the Fourier transform, for example:
std::vector<double> fftMag = /* your FFT magnitudes */
auto irregularity = Informer::Frequency::irregularity(fftMag);There is a built-in function to calculate the normalized magnitudes if you have the result of a real valued FFT in the canonical form of (real[0], real[SR/2], real[1], imag[1], real[2], imag[2], ...):
// With realFftResult being a container with the result of a real valued FFT
std::vector<double> fftMag = Informer::Frequency::magnitudes(realFftResult);For descriptors needing the sample rate, this can be specified (otherwise it is set to 44100 Hz). When a descriptor uses other descriptors (such as kurtosis and skewness), these can be passed as parameters, otherwise they are computed.
Finally, for descriptors expressed in Hertz, like centroid and spread, the frequencies of the FFT bins can be passed as a vector to speed up the function (that would compute them otherwise). A utility function precompute_frequencies is available for this scope:
double sampleRate = 44100.0;
unsigned int fftSize = 8192;
auto precomputed_frequencies = Informer::Frequency::precompute_frequencies(fftSize, sampleRate);For class implementation, it can be instantiated by passing a buffer and a series of FFT magnitudes:
// Sample rate defaults to 44100.0, rolloff point defaults to 0.85,
// previous FFT magnitudes to 0.0 (with same current FFT size)
// Last parameter tells to compute the descriptors immediately
// If buffer or magnitudes are not passed, they default to empty vectors
// and their corresponding descriptors are not computed
Informer::Informer<float> informer(buffer, fftMag, sampleRate, rolloffPoint, previousFft, true);
// Retrieve descriptors
auto peak = informer.get_time_descriptor("peak");
auto centroid = informer.get_frequency_descriptor("centroid"));
// Store new audio values
informer.set_buffer(newBuffer);
informer.set_stft(newMagnitudes);
// Compute new descriptors
informer.compute_descriptors();