Essentia

https://essentia.upf.edu/
Admin
Essentia is an open-source C++ library for audio analysis and music information retrieval that...
Tokens:914,021
Snippets:9,495
Trust Score:9.9
Update:5 months ago
Show doc for...
Tokens:
Raw
### Configure Build System for Examples

Source: https://essentia.upf.edu/howto_standard_extractor.html

Configures the build system to include compilation of examples in release mode.

```bash
./waf configure --mode=release --with-examples


```

--------------------------------

### Example Essentia and MusicExtractor Versions

Source: https://essentia.upf.edu/tutorial_extractors_musicextractor.html

This is an example output showing the versions of Essentia and MusicExtractor.

```text
Essentia version: 2.1-beta6-dev
Essentia version git SHA: v2.1_beta5-409-g84e4a6ee-dirty
Essentia MusicExtractor version: music 2.0
```

--------------------------------

### Compile Examples

Source: https://essentia.upf.edu/howto_standard_extractor.html

Compiles the examples, including any custom extractors that have been added to the build script.

```bash
./waf


```

--------------------------------

### Build and Install Essentia with Emscripten

Source: https://essentia.upf.edu/FAQ.html

Build and install Essentia after configuring it for Emscripten. Use emmake for the waf build and install steps.

```bash
emmake ./waf
emmake ./waf install
```

--------------------------------

### Install pysoundcard

Source: https://essentia.upf.edu/tutorial_tensorflow_real-time_simultaneous_classifiers.html

Install the pysoundcard library, which is used for audio capture.

```bash
!pip install pysoundcard

```

--------------------------------

### start()

Source: https://essentia.upf.edu/doxygen/functions_s.html

Starts a Stopwatch timer.

```APIDOC
## start()

### Description
Starts a Stopwatch timer.

### Signature
start() : Stopwatch
```

--------------------------------

### start()

Source: https://essentia.upf.edu/doxygen/functions_func_s.html

Starts the stopwatch.

```APIDOC
## start()

### Description
Starts the Stopwatch timer.

### Method
(Implicitly a method of Stopwatch)

### Return Value
(Return type depends on Stopwatch implementation)
```

--------------------------------

### Example Output: Frame window and size

Source: https://essentia.upf.edu/tutorial_spectral_constantq-nsg.html

This is an example output indicating the current frame window and frame size being processed during the iteration.

```text
Frame window: triangular
Frame size: 2048
```

```text
Frame window: triangular
Frame size: 4096
```

```text
Frame window: triangular
Frame size: 8192
```

```text
Frame window: triangular
Frame size: 16384
```

```text
Frame window: triangular
Frame size: 32768
```

```text
Frame window: hamming
Frame size: 2048
```

```text
Frame window: hamming
Frame size: 4096
```

```text
Frame window: hamming
Frame size: 8192
```

```text
Frame window: hamming
Frame size: 16384
```

```text
Frame window: hamming
Frame size: 32768
```

```text
Frame window: hann
Frame size: 2048
```

```text
Frame window: hann
Frame size: 4096
```

```text
Frame window: hann
Frame size: 8192
```

```text
Frame window: hann
Frame size: 16384
```

```text
Frame window: hann
Frame size: 32768
```

```text
Frame window: blackmanharris62
Frame size: 2048
```

```text
Frame window: blackmanharris62
Frame size: 4096
```

```text
Frame window: blackmanharris62
Frame size: 8192
```

```text
Frame window: blackmanharris62
Frame size: 16384
```

```text
Frame window: blackmanharris62
Frame size: 32768
```

--------------------------------

### Detect Start Cut in Audio File

Source: https://essentia.upf.edu/tutorial_audioproblems_startstopcut.html

Loads a different audio file, plots its waveform, and visualizes detected start and stop cuts. This example specifically highlights the detection of a start cut.

```python
audio_file = "../../../test/audio/recorded/distorted.wav"
audio = MonoLoader(filename=audio_file)()

duration = len(audio) / sr
time = np.arange(len(audio)) / sr
plt.plot(time, audio)
plt.title("Example of start cut")
plt.xlabel("(s)")
plt.ylabel("(amplitude)")

start_color, stop_color = compute(audio, threshold=-48)

plt.axvline(0.01, color=start_color)
plt.axvline(duration - 0.01, color=stop_color)
```

--------------------------------

### Install pysoundcard

Source: https://essentia.upf.edu/tutorial_tensorflow_real-time_auto-tagging.html

Install the pysoundcard package for audio capture. This is a prerequisite for real-time audio processing.

```python
!pip -q install pysoundcard

```

--------------------------------

### Full Configuration Example

Source: https://essentia.upf.edu/streaming_extractor_music.html

An example profile demonstrating analysis of the first 30 seconds, outputting frame values and statistics, with detailed low-level, rhythm, and tonal parameters.

```yaml
startTime: 0
endTime: 30
outputFrames: 0
outputFormat: json
requireMbid: false
indent: 4

lowlevel:
    frameSize: 2048
    hopSize: 1024
    zeroPadding: 0
    windowType: blackmanharris62
    silentFrames: noise
    stats: ["mean", "var", "median", "min", "max", "dmean", "dmean2", "dvar", "dvar2"]

average_loudness:
    frameSize: 88200
    hopSize: 44100

rhythm:
    method: degara
    minTempo: 40
    maxTempo: 208
    stats: ["mean", "var", "median", "min", "max", "dmean", "dmean2", "dvar", "dvar2"]

tonal:
    frameSize: 4096
    hopSize: 2048
    zeroPadding: 0
    windowType: blackmanharris62
    silentFrames: noise
    stats: ["mean", "var", "median", "min", "max", "dmean", "dmean2", "dvar", "dvar2"]

```

--------------------------------

### Recommended Pipeline for MAEST Models

Source: https://essentia.upf.edu/reference/std_TensorflowPredictMAEST.html

This pipeline demonstrates the recommended setup for using MAEST models, starting with audio loading and resampling, followed by MAEST prediction.

```python
MonoLoader(sampleRate=16000, resampleQuality=4) >> TensorflowPredictMAEST
```

--------------------------------

### Configure and build Essentia with static examples

Source: https://essentia.upf.edu/FAQ.html

Configures the build process to include static examples and then builds Essentia. The static executables will be located in the build/src/examples folder.

```bash
./waf configure  --with-static-examples
./waf
```

--------------------------------

### Install Doxygen and Pip

Source: https://essentia.upf.edu/installing.html

Install Doxygen for documentation generation and pip for Python package management on Linux systems.

```bash
sudo apt-get install doxygen python3-pip

```

--------------------------------

### Install TensorFlow

Source: https://essentia.upf.edu/machine_learning.html

Install the TensorFlow library. This is a prerequisite for building Essentia with TensorFlow support from source.

```bash
pip3 install tensorflow

```

--------------------------------

### Full Profile Example for Specific Analysis

Source: https://essentia.upf.edu/freesound_extractor.html

A comprehensive profile example demonstrating configuration for analyzing the first 30 seconds of audio, outputting frame values and statistical summarization in JSON format.

```yaml
startTime: 0
endTime: 30
outputFrames: 0
outputFormat: json
requireMbid: false
indent: 4

lowlevel:
    frameSize: 2048
    hopSize: 1024
    zeroPadding: 0
    windowType: blackmanharris62
    silentFrames: noise
    stats: ["mean", "var", "median", "min", "max", "dmean", "dmean2", "dvar", "dvar2"]

rhythm:
    method: degara
    minTempo: 40
    maxTempo: 208
    stats: ["mean", "var", "median", "min", "max", "dmean", "dmean2", "dvar", "dvar2"]

tonal:
    frameSize: 4096
    hopSize: 2048
    zeroPadding: 0
    windowType: blackmanharris62
    silentFrames: noise
    stats: ["mean", "var", "median", "min", "max", "dmean", "dmean2", "dvar", "dvar2"]
```

--------------------------------

### start()

Source: https://essentia.upf.edu/doxygen/classTNT_1_1Stopwatch-members.html

Starts or restarts the stopwatch timer.

```APIDOC
## start()

### Description
Starts the stopwatch. If the stopwatch was already running, it will be reset and restarted.

### Method
`inline`

### Parameters
None

### Returns
void
```

--------------------------------

### Install Essentia

Source: https://essentia.upf.edu/machine_learning.html

Install the compiled Essentia library on your system. This command should be run after the build process is complete.

```bash
python3 waf install

```

--------------------------------

### Example Loudness and Dynamic Range Values

Source: https://essentia.upf.edu/tutorial_loudness_envelope.html

Provides example output values for integrated loudness and dynamic range.

```text
Integrated loudness: -13.052407264709473
Dynamic range: 2.255620002746582
```

--------------------------------

### Setup Essentia for TensorFlow Linking

Source: https://essentia.upf.edu/machine_learning.html

Run the setup script to expose TensorFlow shared libraries for linking. This script is part of the Essentia source code.

```bash
cd essentia && src/3rdparty/tensorflow/setup_from_python.sh

```

--------------------------------

### True-Peak Metering Example

Source: https://essentia.upf.edu/tutorial_audioproblems_truepeakdetector.html

This example demonstrates true-peak metering using `TruePeakDetector`. It loads an audio file, applies the detector, and visualizes the original signal, the oversampled signal, and the identified clipping peaks.

```python
from essentia.standard import MonoLoader, TruePeakDetector
import numpy as np
import matplotlib.pyplot as plt

plt.rcParams["figure.figsize"] = (9, 5)

EPS = np.finfo(np.float32).eps

```

```python
sr = 44100

audio_file = "../../../test/audio/recorded/distorted.wav"
audio = MonoLoader(filename=audio_file)()

times = np.arange(len(audio)) / sr
oversampled_times = np.arange(len(audio) * 4) / (sr * 4)

peak_locations, output = TruePeakDetector(version=2)(audio)

n = 3  # Show three examples.
f, axes = plt.subplots(n)
f.subplots_adjust(hspace=0.9)
for idx in range(n):
    p_idx = idx * 100
    l0 = axes[idx].axhline(0, color="r", alpha=0.7, ls="--")
    l1 = axes[idx].plot(oversampled_times, 20 * np.log10(output + EPS), alpha=0.8)
    l2 = axes[idx].plot(times, 20 * np.log10(np.abs(audio + EPS)), marker="o")
    l3 = axes[idx].plot(peak_locations / sr, np.zeros(len(peak_locations)), color="r", marker="x", linestyle="None")

    axes[idx].set_xlim([peak_locations[p_idx] / sr - 0.0002, peak_locations[p_idx] / sr + 0.0002])
    axes[idx].set_ylim([-0.15, 0.15])
    axes[idx].set_title("Clipping peak located at {:.2f}s".format(peak_locations[p_idx] / (sr * 4)))
    axes[idx].set_ylabel("dB")

f.legend([l0, l1[-1], l2[-1], l3[-1]], ["Dynamic range limit (dB)", "Oversampled signal", "Original signal", "Clipped samples"])
plt.show()

```

--------------------------------

### Example Audio File Metadata

Source: https://essentia.upf.edu/tutorial_extractors_musicextractor.html

This is an example output of audio file metadata, including filename, MD5 hash, bit rate, codec, duration, and channel count.

```text
Filename: dubstep.mp3
MD5 hash for the encoded audio: 1e5a598218e9b19cfe04d6c2f61f84a6
Audio bit rate: 192000.0
Audio codec: mp3float
Duration (seconds): 6.896326541900635
Number of channels (mono or stereo): 2.0
```

--------------------------------

### Example Pipeline with TensorflowPredict2D

Source: https://essentia.upf.edu/reference/std_TensorflowPredict2D.html

This example shows a possible pipeline configuration using TensorflowPredictMusiCNN and TensorflowPredict2D. Ensure the graph filenames match your model files.

```python
MonoLoader(sampleRate=16000) >> TensorflowPredictMusiCNN(graphFilename='embedding_model.pb') >> TensorflowPredict2D(graphFilename='classification_model.pb')
```

--------------------------------

### Basic Program Setup and Argument Handling

Source: https://essentia.upf.edu/howto_standard_extractor.html

Initializes the program, checks for correct command-line arguments (audio input and YAML output file), and sets up the essentia::standard namespace. Ensure you have the correct number of arguments when running the executable.

```cpp
using namespace essentia::standard;

int main(int argc, char* argv[]) {

  if (argc != 3) {
    cout << "ERROR: incorrect number of arguments." << endl;
    cout << "Usage: " << argv[0] << " audio_input yaml_output" << endl;
    exit(1);
  }

  string audioFilename = argv[1];
  string outputFilename = argv[2];


```

--------------------------------

### Get Current Time in Seconds

Source: https://essentia.upf.edu/doxygen/tnt__stopwatch_8h_source.html

Returns the current time in seconds since the program started. Requires the \<time.h> header.

```cpp
inline static double seconds(void)
{
const double secs_per_tick = 1.0 / CLOCKS_PER_SEC;
return ( (double) clock() ) * secs_per_tick;
}
```

--------------------------------

### Get build configuration help

Source: https://essentia.upf.edu/FAQ.html

Run this command to display all available build configuration flags and options for the waf build system.

```bash
./waf --help
```

--------------------------------

### Configure and build Essentia for Windows cross-compilation

Source: https://essentia.upf.edu/FAQ.html

Configures Essentia for cross-compilation to Windows 32-bit and builds the library along with static examples. Ensure the Mingw-w64 toolchain is installed.

```bash
./waf configure --with-static-examples --cross-compile-mingw32
./waf
```

--------------------------------

### runPrepare()

Source: https://essentia.upf.edu/doxygen/functions_r.html

Prepares the network for running.

```APIDOC
## runPrepare()

### Description
Prepares the network for running.

### Returns
Network
```

--------------------------------

### Compare Network Topologies

Source: https://essentia.upf.edu/doxygen/graphutils_8h_source.html

Compares the topologies of two networks starting from given root nodes. It involves getting node lists, ordering them, and comparing adjacency matrices across permutations to determine equality.

```cpp
template <typename NodeType>
bool areNetworkTopologiesEqual(NodeType* n1, NodeType* n2) {
 // this function compares both network and decide whether they have the same topology
 // to do this, we apply the following algorithm (not the most efficient, yeah)
 // - get list of all nodes (if not same number -> different networks)
 // - order them by alphabetical order (need to be same order)
 // - for each duplicate node name, generate permutations for this node
 // - for each permutation, generate adjacency matrix and compare them:
 // - if there is 1 permutation for which the matrices are equal, then the networks are equal
 // - if the matrices are different for all the permutations, then the networks are different

 // get the list of nodes and their names
 std::vector<std::pair<NodeType*, std::string> > nodes1 = depthFirstMap(n1, getIdentityAndName);
 std::vector<std::pair<NodeType*, std::string> > nodes2 = depthFirstMap(n2, getIdentityAndName);


```

--------------------------------

### Start Stopwatch

Source: https://essentia.upf.edu/doxygen/tnt__stopwatch_8h_source.html

Starts or restarts the stopwatch. Resets the total time and records the current start time.

```cpp
void Stopwatch::start()
{
running_ = 1;
total_ = 0.0;
start_time_ = seconds();
}
```

--------------------------------

### Create and Use Parameters

Source: https://essentia.upf.edu/design_overview.html

Demonstrates creating Parameter objects with different data types and retrieving them. Type conversions are allowed if they are sensible.

```cpp
Parameter param1(23);
int param1_int = param1.toInt();

std::vector<Real> v;
// v is empty
v.push_back(1.2);
// v = [ 1.2 ]
v.push_back(2.3);
// v = [ 1.2, 2.3 ]
Parameter param2(v);
std::vector<Real> param2_vector = param2.toVectorReal();

// conversions between types are allowed as long as they make sense
Parameter param3(117);     // constructed from an integer
Real p3 = param3.toReal(); // works because an integer is also a float

```

--------------------------------

### View All Configuration Options

Source: https://essentia.upf.edu/installing.html

Display the full list of available configuration options for the waf build script.

```bash
python3 waf --help

```

--------------------------------

### Install Python Environment and Packages on macOS

Source: https://essentia.upf.edu/installing.html

Installs a Python framework using Homebrew and then installs essential Python packages like NumPy and Matplotlib. Avoids using the system Python.

```bash
brew install python --framework
pip install ipython numpy matplotlib pyyaml

```

--------------------------------

### create()

Source: https://essentia.upf.edu/doxygen/functions_func_c.html

Creates instances of various components like AudioContext, EssentiaFactory, and Range.

```APIDOC
## create()

### Description
Creates instances of various components like AudioContext, EssentiaFactory, and Range.

### Signature
`create() : AudioContext , EssentiaFactory< BaseAlgorithm > , EssentiaFactory< BaseAlgorithm >::Registrar< ConcreteProduct, ReferenceConcreteProduct > , Range`
```

--------------------------------

### Macro Instantiations for Algorithm Creation with Parameters

Source: https://essentia.upf.edu/doxygen/algorithmfactory__impl_8h_source.html

Examples of how the `CREATE_I`, `P`, `AP`, `CREATE_I_BEG`, and `CREATE_I_END` macros are used to instantiate algorithms with up to 12 parameters. Each instantiation defines the algorithm ID, parameter names, and their corresponding values.

```cpp
CREATE_I P(1) CREATE_I_BEG AP(1) CREATE_I_END
```

```cpp
CREATE_I P(1) P(2) CREATE_I_BEG AP(1) AP(2) CREATE_I_END
```

```cpp
CREATE_I P(1) P(2) P(3) CREATE_I_BEG AP(1) AP(2) AP(3) CREATE_I_END
```

```cpp
CREATE_I P(1) P(2) P(3) P(4) CREATE_I_BEG AP(1) AP(2) AP(3) AP(4) CREATE_I_END
```

```cpp
CREATE_I P(1) P(2) P(3) P(4) P(5) CREATE_I_BEG AP(1) AP(2) AP(3) AP(4) AP(5) CREATE_I_END
```

```cpp
CREATE_I P(1) P(2) P(3) P(4) P(5) P(6) CREATE_I_BEG AP(1) AP(2) AP(3) AP(4) AP(5) AP(6) CREATE_I_END
```

```cpp
CREATE_I P(1) P(2) P(3) P(4) P(5) P(6) P(7)
CREATE_I_BEG AP(1) AP(2) AP(3) AP(4) AP(5) AP(6) AP(7) CREATE_I_END
```

```cpp
CREATE_I P(1) P(2) P(3) P(4) P(5) P(6) P(7) P(8)
CREATE_I_BEG AP(1) AP(2) AP(3) AP(4) AP(5) AP(6) AP(7) AP(8) CREATE_I_END
```

```cpp
CREATE_I P(1) P(2) P(3) P(4) P(5) P(6) P(7) P(8) P(9)
CREATE_I_BEG AP(1) AP(2) AP(3) AP(4) AP(5) AP(6) AP(7) AP(8) AP(9) CREATE_I_END
```

```cpp
CREATE_I P(1) P(2) P(3) P(4) P(5) P(6) P(7) P(8) P(9) P(10)
CREATE_I_BEG AP(1) AP(2) AP(3) AP(4) AP(5) AP(6) AP(7) AP(8) AP(9) AP(10) CREATE_I_END
```

```cpp
CREATE_I P(1) P(2) P(3) P(4) P(5) P(6) P(7) P(8) P(9) P(10) P(11)
CREATE_I_BEG AP(1) AP(2) AP(3) AP(4) AP(5) AP(6) AP(7) AP(8) AP(9) AP(10) AP(11) CREATE_I_END
```

```cpp
CREATE_I P(1) P(2) P(3) P(4) P(5) P(6) P(7) P(8) P(9) P(10) P(11) P(12)
```

--------------------------------

### Namespace Functions Starting with 'i'

Source: https://essentia.upf.edu/doxygen/namespacemembers_func_i.html

This section details functions available in the 'essentia' namespace that start with the letter 'i'.

```APIDOC
## ilog10()

### Description
Calculates the base-10 logarithm of a number.

### Namespace
essentia

## indexOf()

### Description
Finds the index of a specific element within a sequence.

### Namespace
essentia

## init()

### Description
Initializes a component or system.

### Namespace
essentia

## initializeFFT()

### Description
Initializes the Fast Fourier Transform (FFT) module.

### Namespace
essentia

## instantPower()

### Description
Calculates the instantaneous power of a signal.

### Namespace
essentia

## isBigEndian()

### Description
Checks if the system's endianness is big-endian.

### Namespace
essentia

## isDenormal()

### Description
Checks if a number is denormalized.

### Namespace
essentia

## isInitialized()

### Description
Checks if a component or system has been initialized.

### Namespace
essentia

## isPowerOfTwo()

### Description
Checks if a number is a power of two.

### Namespace
essentia

## isSilent()

### Description
Checks if the audio output is silent.

### Namespace
essentia

## isValid()

### Description
Checks if a value or object is valid.

### Namespace
essentia
```

--------------------------------

### begin()

Source: https://essentia.upf.edu/doxygen/functions_func_b.html

Initializes or returns a reference to the beginning of a container or sequence. It is overloaded for different template types.

```APIDOC
## begin()

### Description
Initializes or returns a reference to the beginning of a container or sequence.

### Signature
i_refvec< T > begin()
Vector< T > begin()
```

--------------------------------

### open

Source: https://essentia.upf.edu/doxygen/audiocontext_8h_source.html

Opens the audio context, preparing it for writing.

```APIDOC
## open

### Description
Opens the audio context, making it ready to accept audio data for writing.

### Method
void open()

### Code
essentia::AudioContext::open
```

--------------------------------

### init()

Source: https://essentia.upf.edu/doxygen/classessentia_1_1EssentiaFactory.html

Initializes the EssentiaFactory.

```APIDOC
## init()

### Description
Initializes the EssentiaFactory. This method should be called before using other factory methods.

### Signature
`static void init()`
```

--------------------------------

### Example Classification Output

Source: https://essentia.upf.edu/tutorial_tensorflow_auto-tagging_classification_embeddings.html

Example output showing the predicted probabilities for danceable and not danceable classes.

```text
danceable: 99.8%
not_danceable: 0.2%

```

--------------------------------

### Namespace Members starting with 'h'

Source: https://essentia.upf.edu/doxygen/namespacemembers_h.html

This section details functions and other members within namespaces that start with the letter 'h'.

```APIDOC
## Namespace Members - h

### - h -

  * heavisideStepFunction() : essentia
  * hist() : essentia
  * hypot() : TNT
  * hz2bark() : essentia
  * hz2cents() : essentia
  * hz2hz() : essentia
  * hz2mel() : essentia
  * hz2mel10() : essentia
  * hz2melSlaney() : essentia
  * hz2midi() : essentia
  * hz2note() : essentia
```

--------------------------------

### Instantiate Streaming Algorithms

Source: https://essentia.upf.edu/essentia_python_tutorial.html

Create instances of various audio processing algorithms for use in the streaming pipeline. Ensure parameters like filename, frame size, and hop size are correctly set.

```python
loader = MonoLoader(filename = '../../../test/audio/recorded/dubstep.wav')
frameCutter = FrameCutter(frameSize = 1024, hopSize = 512)
w = Windowing(type = 'hann')
spec = Spectrum()
mfcc = MFCC()

```

--------------------------------

### Algorithm Creation and Configuration

Source: https://essentia.upf.edu/doxygen/algorithmfactory__impl_8h.html

Configures an algorithm with default parameters and returns the configured algorithm instance.

```cpp
#define CREATE_I_END  
algo->setParameters(params); 
E_DEBUG(EFactory, BaseAlgorithm::processingMode << ": Configuring " << id << " with default parameters"); 
algo->configure(); 
E_DEBUG(EFactory, BaseAlgorithm::processingMode << ": Creating " << id << " ok!"); 
return algo; 
}
```

--------------------------------

### Install Python Dependencies for Tests

Source: https://essentia.upf.edu/installing.html

Install additional Python dependencies required for running some of the Python unit tests.

```bash
pip3 install scikit-learn

```

--------------------------------

### init()

Source: https://essentia.upf.edu/doxygen/namespacemembers_i.html

Initializes the Essentia library or a specific component.

```APIDOC
## init()

### Description
Initializes the Essentia library or a specific component.

### Namespace
essentia
```

--------------------------------

### Install Python Documentation Dependencies

Source: https://essentia.upf.edu/installing.html

Install Python packages required for building documentation with Sphinx. This may require sudo privileges.

```bash
pip3 install sphinx pyparsing sphinxcontrib-doxylink docutils jupyter sphinx-toolbox nbformat gitpython
sudo apt-get install pandoc

```

--------------------------------

### open()

Source: https://essentia.upf.edu/doxygen/classessentia_1_1AudioContext.html

Opens the audio context.

```APIDOC
## ◆ open()
void open  | ( | | ) |   
---|---|---|---

```

--------------------------------

### Install GPU Support Components

Source: https://essentia.upf.edu/machine_learning.html

Install CUDA, CuDNN, and essentia-tensorflow within the Conda environment. These are necessary for running inference on a GPU.

```bash
conda install -c conda-forge -y cudatoolkit=11.2 cudnn=8.1
pip install essentia-tensorflow

```

--------------------------------

### Install Essentia with TensorFlow Support

Source: https://essentia.upf.edu/machine_learning.html

Install the essentia-tensorflow Python package to enable TensorFlow model inference. This is the recommended method for most users.

```bash
pip install essentia-tensorflow

```

--------------------------------

### create_i() Method (21 parameters)

Source: https://essentia.upf.edu/doxygen/classessentia_1_1EssentiaFactory.html

This method is used to create a BaseAlgorithm instance with up to 21 parameters. It takes an ID, a name, and a Parameter object for each of the 21 potential configuration values.

```APIDOC
## create_i()

### Description
Creates a BaseAlgorithm instance with a specified ID and up to 21 name-value pairs for configuration.

### Signature
`BaseAlgorithm * create_i(const std::string & _id_, const std::string & _name1_, const Parameter & _value1_, ..., const std::string & _name21_, const Parameter & _value21_) const`

### Parameters
- `_id_` (const std::string &): The unique identifier for the algorithm.
- `_name1_` to `_name21_` (const std::string &): The names of the parameters.
- `_value1_` to `_value21_` (const Parameter &): The values of the parameters.
```

--------------------------------

### Install build dependencies on Linux

Source: https://essentia.upf.edu/FAQ.html

Installs yasm and cmake, which are required for building static versions of Essentia and some of its dependencies on Linux systems.

```bash
apt-get install yasm cmake
```

--------------------------------

### create_i() Method (22 parameters)

Source: https://essentia.upf.edu/doxygen/classessentia_1_1EssentiaFactory.html

This method is used to create a BaseAlgorithm instance with up to 22 parameters. It takes an ID, a name, and a Parameter object for each of the 22 potential configuration values.

```APIDOC
## create_i()

### Description
Creates a BaseAlgorithm instance with a specified ID and up to 22 name-value pairs for configuration.

### Signature
`BaseAlgorithm * create_i(const std::string & _id_, const std::string & _name1_, const Parameter & _value1_, ..., const std::string & _name22_, const Parameter & _value22_) const`

### Parameters
- `_id_` (const std::string &): The unique identifier for the algorithm.
- `_name1_` to `_name22_` (const std::string &): The names of the parameters.
- `_value1_` to `_value22_` (const Parameter &): The values of the parameters.
```

--------------------------------

### Install Essentia with TensorFlow Support

Source: https://essentia.upf.edu/tutorial_tensorflow_auto-tagging_classification_embeddings.html

Install the Essentia package with TensorFlow support using pip. This is currently available for Linux with specific Python versions.

```bash
!pip install -q essentia-tensorflow

```

--------------------------------

### runPrepare()

Source: https://essentia.upf.edu/doxygen/classessentia_1_1scheduler_1_1Network.html

Performs the necessary preparation for processing tokens within the network.

```APIDOC
## ◆ runPrepare()

### Description
Does the preparation needed to process the tokens of the network

### Signature
`void runPrepare()
`
```

--------------------------------

### Install Essentia Prerequisites on macOS

Source: https://essentia.upf.edu/installing.html

Installs core development prerequisites for Essentia on macOS using Homebrew. Includes pkg-config, GCC, and essential libraries.

```bash
brew install pkg-config gcc readline sqlite gdbm freetype libpng

```

--------------------------------

### Install Xcode Command Line Tools on macOS

Source: https://essentia.upf.edu/installing.html

Installs the necessary command-line developer tools for Xcode on macOS. This is a prerequisite for compiling software from source.

```bash
xcode-select --install

```

--------------------------------

### Install Essentia Dependencies

Source: https://essentia.upf.edu/machine_learning.html

Install the necessary system dependencies for building Essentia with Python 3 support. This command is for Debian-based systems like Ubuntu.

```bash
apt-get install build-essential libyaml-dev libfftw3-dev libavcodec-dev libavformat-dev libavutil-dev libavresample-dev python-dev libsamplerate0-dev libtag1-dev libchromaprint-dev python-six python3-dev python3-numpy-dev python3-numpy python3-yaml libeigen3-dev

```

--------------------------------

### Install Mingw-w64 GCC for Windows cross-compilation

Source: https://essentia.upf.edu/FAQ.html

Installs the Mingw-w64 GCC toolchain on Debian/Ubuntu systems, which is required for cross-compiling Essentia for Windows on a Linux environment.

```bash
sudo apt-get install g++-mingw-w64
```

--------------------------------

### create

Source: https://essentia.upf.edu/doxygen/classessentia_1_1AudioContext.html

Creates a new audio file with specified parameters.

```APIDOC
## create

### Description
Creates a new audio file with the specified filename, format, number of channels, sample rate, and bitrate.

### Method
create

### Parameters
#### Path Parameters
- **filename** (const std::string &) - Description of the filename parameter.
- **format** (const std::string &) - Description of the format parameter.
- **nChannels** (int) - Description of the nChannels parameter.
- **sampleRate** (int) - Description of the sampleRate parameter.
- **bitrate** (int) - Description of the bitrate parameter.

### Returns
- int - Description of the return value.
```

--------------------------------

### Instantiate Streaming Constant-Q Algorithms

Source: https://essentia.upf.edu/tutorial_spectral_constantq-nsg.html

Initializes algorithms for frame-wise Constant-Q Transform analysis in streaming mode. This includes setting up the Constant-Q and Inverse Constant-Q algorithms, a mono loader, windowing, frame cutting, and Cartesian-to-Polar converters. A Pool object is created to store the results.

```python
kwargs['inputSize'] = 4096 * 2

CQAlgo = streaming.NSGConstantQStreaming(**kwargs)
ICQAlgo = streaming.NSGIConstantQ(**kwargs)
loader = streaming.MonoLoader(filename='../../../test/audio/recorded/vignesh.wav')
w = streaming.Windowing(type='triangular',normalized=False, zeroPhase=False)
frameCutter = streaming.FrameCutter(frameSize=kwargs['inputSize'], hopSize=kwargs['inputSize']/2)

CQc2p = streaming.CartesianToPolar()
DCc2p = streaming.CartesianToPolar()
NFc2p = streaming.CartesianToPolar()

pool = Pool()

```

--------------------------------

### Install build dependencies on macOS

Source: https://essentia.upf.edu/FAQ.html

Installs yasm, cmake, and wget using Homebrew, which are necessary for building static versions of Essentia and its dependencies on macOS.

```bash
brew install yasm cmake wget
```

--------------------------------

### create

Source: https://essentia.upf.edu/doxygen/audiocontext_8h_source.html

Creates a new audio context with specified parameters for a given filename and format.

```APIDOC
## create

### Description
Creates an audio context for writing audio data to a file.

### Parameters
#### Path Parameters
- **filename** (const std::string&amp;) - The name of the output audio file.
- **format** (const std::string&amp;) - The format of the audio file (e.g., "WAV", "OGG").
- **nChannels** (int) - The number of audio channels.
- **sampleRate** (int) - The sample rate of the audio.
- **bitrate** (int) - The bitrate of the audio file.

### Method
int create(const std::string&amp; filename, const std::string&amp; format,
 int nChannels, int sampleRate, int bitrate)

### Code
essentia::AudioContext::create
```

--------------------------------

### isOpen

Source: https://essentia.upf.edu/doxygen/audiocontext_8h_source.html

Checks if the audio context is currently open and ready for operations.

```APIDOC
## isOpen

### Description
Returns true if the audio context is open, false otherwise.

### Method
bool isOpen() const

### Code
essentia::AudioContext::isOpen
```

--------------------------------

### Class Members starting with 'k'

Source: https://essentia.upf.edu/doxygen/functions_k.html

This section details members of various classes that start with the letter 'k'. It includes both variables and functions, along with the classes they belong to.

```APIDOC
## Class Members starting with 'k'

### Description
This section details members of various classes that start with the letter 'k'. It includes both variables and functions, along with the classes they belong to.

### Members

- **k_** : Fortran_Array3D< T >
- **kAvailable** : RingBufferImpl
- **keys()** : EssentiaFactory< BaseAlgorithm >, EssentiaMap< KeyType, ValueType, Compare >, OrderedMap< T >
- **kSpace** : RingBufferImpl
```

--------------------------------

### open

Source: https://essentia.upf.edu/doxygen/classessentia_1_1AudioContext.html

Opens an existing audio file for writing.

```APIDOC
## open

### Description
Opens the audio file specified during creation for writing.

### Method
open
```

--------------------------------

### Model Schema Example

Source: https://essentia.upf.edu/tutorial_tensorflow_auto-tagging_classification_embeddings.html

An example of a model's schema, indicating input/output layers and their properties. The 'description' field for 'model/dense/BiasAdd' suggests it's suitable for embeddings.

```json
{
'inputs': [{'name': 'model/Placeholder', 'type': 'float', 'shape': [187, 96]}],
'outputs': [{'name': 'model/Sigmoid', 'type': 'float', 'shape': [1, 50], 'op': 'Sigmoid'}, {'name': 'model/dense_1/BiasAdd', 'type': 'float', 'shape': [1, 50], 'op': 'fully connected', 'description': 'logits'}, {'name': 'model/dense/BiasAdd', 'type': 'float', 'shape': [1, 200], 'op': 'fully connected', 'description': 'embeddings'}]
}
```

--------------------------------

### AcoustID Query Response Example

Source: https://essentia.upf.edu/tutorial_fingerprinting_chromaprint.html

This is an example JSON response from an AcoustID query, indicating the status, identified recordings, artists, duration, and release group information.

```json
{"status": "ok", "results": [{"recordings": [{"artists": [{"id": "b02d0e59-b9c2-4009-9ebd-bfac7ebd-bfac7ffa0ca3", "name": "Desakato"}], "duration": 129, "releasegroups": [{"type": "Album", "id": "a38dc1ea-74fc-44c2-a31c-783810ba1568", "title": "La Teoru00eda del Fuego"}], "title": "Tiempo de cobardes", "id": "9b91e561-a9bf-415a-957b-33e6130aba76"}], "score": 0.937038, "id": "23495e47-d670-4e86-bd08-b1b24a84f7c7"}]}

```

--------------------------------

### create() - 13 Parameters

Source: https://essentia.upf.edu/doxygen/classessentia_1_1EssentiaFactory.html

Creates a BaseAlgorithm instance with an ID, name, value pairs for up to 13 parameters.

```APIDOC
## create()

### Description
Creates a BaseAlgorithm instance with an ID and up to 13 named parameters, each with a corresponding value.

### Signature
```cpp
static BaseAlgorithm* create(const std::string& _id, const std::string& _name1, const Parameter& _value1, const std::string& _name2, const Parameter& _value2, const std::string& _name3, const Parameter& _value3, const std::string& _name4, const Parameter& _value4, const std::string& _name5, const Parameter& _value5, const std::string& _name6, const Parameter& _value6, const std::string& _name7, const Parameter& _value7, const std::string& _name8, const Parameter& _value8, const std::string& _name9, const Parameter& _value9, const std::string& _name10, const Parameter& _value10, const std::string& _name11, const Parameter& _value11, const std::string& _name12, const Parameter& _value12, const std::string& _name13, const Parameter& _value13)
```

### Parameters
- **_id** (const std::string&): The unique identifier for the algorithm.
- **_name1** (const std::string&): The name of the first parameter.
- **_value1** (const Parameter&): The value of the first parameter.
- **_name2** (const std::string&): The name of the second parameter.
- **_value2** (const Parameter&): The value of the second parameter.
- **_name3** (const std::string&): The name of the third parameter.
- **_value3** (const Parameter&): The value of the third parameter.
- **_name4** (const std::string&): The name of the fourth parameter.
- **_value4** (const Parameter&): The value of the fourth parameter.
- **_name5** (const std::string&): The name of the fifth parameter.
- **_value5** (const Parameter&): The value of the fifth parameter.
- **_name6** (const std::string&): The name of the sixth parameter.
- **_value6** (const Parameter&): The value of the sixth parameter.
- **_name7** (const std::string&): The name of the seventh parameter.
- **_value7** (const Parameter&): The value of the seventh parameter.
- **_name8** (const std::string&): The name of the eighth parameter.
- **_value8** (const Parameter&): The value of the eighth parameter.
- **_name9** (const std::string&): The name of the ninth parameter.
- **_value9** (const Parameter&): The value of the ninth parameter.
- **_name10** (const std::string&): The name of the tenth parameter.
- **_value10** (const Parameter&): The value of the tenth parameter.
- **_name11** (const std::string&): The name of the eleventh parameter.
- **_value11** (const Parameter&): The value of the eleventh parameter.
- **_name12** (const std::string&): The name of the twelfth parameter.
- **_value12** (const Parameter&): The value of the twelfth parameter.
- **_name13** (const std::string&): The name of the thirteenth parameter.
- **_value13** (const Parameter&): The value of the thirteenth parameter.

### Returns
- A pointer to the created BaseAlgorithm object.
```

--------------------------------

### Install Essentia Dependencies on macOS

Source: https://essentia.upf.edu/installing.html

Installs Essentia's direct dependencies on macOS using Homebrew. This includes libraries like Eigen, libyaml, FFTW, and FFmpeg.

```bash
brew install eigen libyaml fftw ffmpeg@2.8 libsamplerate libtag chromaprint tensorflow

```

--------------------------------

### EssentiaFactory::init

Source: https://essentia.upf.edu/doxygen/classessentia_1_1EssentiaFactory-members.html

Initializes the Essentia environment.

```APIDOC
## EssentiaFactory::init

### Description
Initializes the Essentia environment. This method should be called before using any other EssentiaFactory functions.

### Method
static void init()

### Remarks
This is a static method and does not take any parameters.
```

--------------------------------

### Install TensorFlow Shared Library

Source: https://essentia.upf.edu/installing.html

Installs the TensorFlow shared library using a helper script within the Essentia source code. This is for users who need TensorFlow integration.

```bash
src/3rdparty/tensorflow/setup_from_libtensorflow.sh

```

--------------------------------

### create() - 15 Parameters

Source: https://essentia.upf.edu/doxygen/classessentia_1_1EssentiaFactory.html

Creates a BaseAlgorithm instance with an ID, name, value pairs for up to 15 parameters.

```APIDOC
## create()

### Description
Creates a BaseAlgorithm instance with an ID and up to 15 named parameters, each with a corresponding value.

### Signature
```cpp
static BaseAlgorithm* create(const std::string& _id, const std::string& _name1, const Parameter& _value1, const std::string& _name2, const Parameter& _value2, const std::string& _name3, const Parameter& _value3, const std::string& _name4, const Parameter& _value4, const std::string& _name5, const Parameter& _value5, const std::string& _name6, const Parameter& _value6, const std::string& _name7, const Parameter& _value7, const std::string& _name8, const Parameter& _value8, const std::string& _name9, const Parameter& _value9, const std::string& _name10, const Parameter& _value10, const std::string& _name11, const Parameter& _value11, const std::string& _name12, const Parameter& _value12, const std::string& _name13, const Parameter& _value13, const std::string& _name14, const Parameter& _value14, const std::string& _name15, const Parameter& _value15)
```

### Parameters
- **_id** (const std::string&): The unique identifier for the algorithm.
- **_name1** (const std::string&): The name of the first parameter.
- **_value1** (const Parameter&): The value of the first parameter.
- **_name2** (const std::string&): The name of the second parameter.
- **_value2** (const Parameter&): The value of the second parameter.
- **_name3** (const std::string&): The name of the third parameter.
- **_value3** (const Parameter&): The value of the third parameter.
- **_name4** (const std::string&): The name of the fourth parameter.
- **_value4** (const Parameter&): The value of the fourth parameter.
- **_name5** (const std::string&): The name of the fifth parameter.
- **_value5** (const Parameter&): The value of the fifth parameter.
- **_name6** (const std::string&): The name of the sixth parameter.
- **_value6** (const Parameter&): The value of the sixth parameter.
- **_name7** (const std::string&): The name of the seventh parameter.
- **_value7** (const Parameter&): The value of the seventh parameter.
- **_name8** (const std::string&): The name of the eighth parameter.
- **_value8** (const Parameter&): The value of the eighth parameter.
- **_name9** (const std::string&): The name of the ninth parameter.
- **_value9** (const Parameter&): The value of the ninth parameter.
- **_name10** (const std::string&): The name of the tenth parameter.
- **_value10** (const Parameter&): The value of the tenth parameter.
- **_name11** (const std::string&): The name of the eleventh parameter.
- **_value11** (const Parameter&): The value of the eleventh parameter.
- **_name12** (const std::string&): The name of the twelfth parameter.
- **_value12** (const Parameter&): The value of the twelfth parameter.
- **_name13** (const std::string&): The name of the thirteenth parameter.
- **_value13** (const Parameter&): The value of the thirteenth parameter.
- **_name14** (const std::string&): The name of the fourteenth parameter.
- **_value14** (const Parameter&): The value of the fourteenth parameter.
- **_name15** (const std::string&): The name of the fifteenth parameter.
- **_value15** (const Parameter&): The value of the fifteenth parameter.

### Returns
- A pointer to the created BaseAlgorithm object.
```
Tokens:
Raw