RNNoise

https://github.com/xiph/rnnoise
Admin
RNNoise is a noise suppression library based on a recurrent neural network, designed for real-time...
Tokens:4,509
Snippets:33
Trust Score:7.7
License:BSD-3-Clause
Update:1 month ago
Show doc for...
Tokens:
Raw
### Import Exchange Modules for Torch and TensorFlow

Source: https://github.com/xiph/rnnoise/blob/main/torch/weight-exchange/README.md

Import submodules for handling weights from PyTorch ('exchange.torch') and TensorFlow ('exchange.tf'). These imports require the respective libraries (torch and tensorflow) to be installed.

```python
import exchange.torch
import exchange.tf
```

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

### Initialize DenoiseState with Default Model (C)

Source: https://context7.com/xiph/rnnoise/llms.txt

Creates a new denoising state using the library's built-in noise suppression model. The state object must be destroyed after use to free resources. This is the primary function to get started with RNNoise.

```c
#include "rnnoise.h"

int main() {
    // Create denoise state with default model
    DenoiseState *st = rnnoise_create(NULL);
    if (st == NULL) {
        fprintf(stderr, "Failed to create denoise state\n");
        return 1;
    }

    // Process audio frames here...

    // Clean up
    rnnoise_destroy(st);
    return 0;
}
```

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

### Build RNNoise Library with Custom Compilation Flags

Source: https://context7.com/xiph/rnnoise/llms.txt

Compiles the RNNoise library with specific optimizations, such as AVX2 support for modern CPUs. This involves configuring the build system with appropriate CFLAGS and then compiling. It also shows how to build without the default model for runtime loading and how to compile example tools.

```bash
# Clone and prepare
git clone https://gitlab.xiph.org/xiph/rnnoise.git
cd rnnoise

# Build with AVX2 support (recommended for modern CPUs)
./autogen.sh
./configure --enable-x86-rtcd CFLAGS="-O3 -march=native"
make
sudo make install

# Build without default model (for runtime loading only)
./configure CFLAGS="-O3 -march=native -DUSE_WEIGHTS_FILE"
make

# Build examples
./configure --enable-examples
make
./examples/rnnoise_demo input.raw output.raw

# Expected output format: 16-bit PCM, mono, 48 kHz
```

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

### Get RNNoise Frame Size (C)

Source: https://context7.com/xiph/rnnoise/llms.txt

Retrieves the required frame size for audio processing in RNNoise. This function consistently returns 480 samples, corresponding to 10ms of audio at the library's standard 48 kHz sample rate. It aids in correctly allocating audio buffers.

```c
#include <stdio.h>
#include "rnnoise.h"

int main() {
    int frame_size = rnnoise_get_frame_size();
    printf("RNNoise frame size: %d samples\n", frame_size);
    printf("At 48 kHz, this is %.1f ms\n",
           (float)frame_size / 48000.0f * 1000.0f);

    // Allocate buffers with correct size
    float *input_buffer = malloc(frame_size * sizeof(float));
    float *output_buffer = malloc(frame_size * sizeof(float));

    // Use buffers...

    free(input_buffer);
    free(output_buffer);
    return 0;
}
```

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

### RNNoise Command-Line Demo Tool

Source: https://context7.com/xiph/rnnoise/llms.txt

Processes raw 16-bit PCM audio files using the RNNoise noise suppression pipeline. The tool operates directly on raw audio data without WAV headers. Input audio needs to be converted to raw format (e.g., using ffmpeg), processed by the tool, and then can be converted back to WAV for playback.

```bash
# Prepare input audio (must be 16-bit PCM, mono, 48kHz, raw format)
# Convert from WAV using ffmpeg or sox:
ffmpeg -i noisy_input.wav -f s16le -acodec pcm_s16le -ar 48000 -ac 1 noisy_input.raw

# Run noise suppression
./examples/rnnoise_demo noisy_input.raw denoised_output.raw

# Convert back to WAV for playback
ffmpeg -f s16le -ar 48000 -ac 1 -i denoised_output.raw denoised_output.wav

# Note: Input and output are RAW format, not WAV
# Each sample is a 16-bit signed integer (machine endian)
# No headers or metadata included
```

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

### Generate Training Features

Source: https://context7.com/xiph/rnnoise/llms.txt

Creates training feature files from clean speech and noise samples using a build tool. This is the initial step for custom model training. It takes RIR list, clean speech, background noise, foreground noise, and an output file name with the number of sequences as input.

```bash
# Build the feature dumping tool
./autogen.sh
./configure
make

# Generate training features with RIR augmentation
./dump_features -rir_list rir_list.txt \
    clean_speech.pcm \
    background_noise.pcm \
    foreground_noise.pcm \
    training_features.f32 \
    200000

# Output: training_features.f32 containing 200,000 sequences
# Each sequence is 98 float32 values per frame
# Format: [65 input features, 32 gain targets, 1 VAD target]
```

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

### Export Trained PyTorch Model to C Code

Source: https://context7.com/xiph/rnnoise/llms.txt

Converts a trained PyTorch model into optimized C source files. This process can optionally include quantization to reduce model size, impacting accuracy slightly. The output includes .c and .h files that can be copied into the project's src directory and used to rebuild the library.

```python
#!/usr/bin/env python3
import sys
sys.path.append('./torch/rnnoise')

# Export with quantization
"""
python3 dump_rnnoise_weights.py \
    --quantize \
    output_models/checkpoints/rnnoise_50.pth \
    exported_c_code/

# Generated files:
# exported_c_code/rnnoise_data.c
# exported_c_code/rnnoise_data.h

# Copy to src/ directory
cp exported_c_code/rnnoise_data.c src/
cp exported_c_code/rnnoise_data.h src/

# Rebuild library with new model
make clean
make
make install
"""

# Without quantization (larger but potentially more accurate)
"""
python3 dump_rnnoise_weights.py \
    output_models/checkpoints/rnnoise_50.pth \
    exported_c_code/
"""

```

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

### C: Initialize RNNoise State with Pre-allocated Memory

Source: https://context7.com/xiph/rnnoise/llms.txt

Initializes the RNNoise denoise state using a pre-allocated memory buffer. This method avoids dynamic allocation and is ideal for embedded systems. It requires the `rnnoise.h` header and standard C libraries like `stdlib.h`. The function `rnnoise_get_size` determines the buffer size, followed by `malloc` for allocation and `rnnoise_init` for initialization.

```c
#include <stdlib.h>
#include "rnnoise.h"
#include <stdio.h>

int main() {
    int state_size;
    void *state_memory;
    DenoiseState *st;

    // Get required memory size
    state_size = rnnoise_get_size();
    printf("DenoiseState requires %d bytes\n", state_size);

    // Allocate memory
    state_memory = malloc(state_size);
    if (state_memory == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return 1;
    }

    // Initialize pre-allocated state
    st = (DenoiseState *)state_memory;
    if (rnnoise_init(st, NULL) != 0) {
        fprintf(stderr, "Initialization failed\n");
        free(state_memory);
        return 1;
    }

    // Process audio frames...

    // No rnnoise_destroy() needed for pre-allocated state
    free(state_memory);
    return 0;
}
```

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

### Load Model from Memory Buffer (C)

Source: https://context7.com/xiph/rnnoise/llms.txt

Loads an RNNoise model directly from a memory buffer containing the model's binary data. This is useful for embedded systems or applications where models are bundled as resources. The buffer must remain valid throughout the model's usage.

```c
#include <stdio.h>
#include <stdlib.h>
#include "rnnoise.h"

int main() {
    FILE *f;
    long file_size;
    unsigned char *buffer;
    RNNModel *model;
    DenoiseState *st;

    // Read entire model file into memory
    f = fopen("weights_blob.bin", "rb");
    fseek(f, 0, SEEK_END);
    file_size = ftell(f);
    fseek(f, 0, SEEK_SET);

    buffer = malloc(file_size);
    fread(buffer, 1, file_size, f);
    fclose(f);

    // Load model from buffer (buffer must remain valid)
    model = rnnoise_model_from_buffer(buffer, file_size);
    st = rnnoise_create(model);

    // Process audio...

    rnnoise_destroy(st);
    rnnoise_model_free(model);
    free(buffer);

    return 0;
}
```

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

### Export RNNoise Model as Binary Blob

Source: https://context7.com/xiph/rnnoise/llms.txt

Generates a loadable binary model file from a compiled RNNoise library that has embedded weights. This involves copying custom C data files into the src directory, rebuilding the library, and then running a tool to export the weights. The generated blob can be loaded at runtime using `rnnoise_model_from_file()`.

```bash
# Build with your custom model
cd src
cp my_rnnoise_data.c rnnoise_data.c
cp my_rnnoise_data.h rnnoise_data.h
cd ..
make

# Export model to binary format
./examples/dump_weights_blob

# Generated: weights_blob.bin
# This file can be loaded at runtime using rnnoise_model_from_file()

# Example: Load binary model in C
"""
FILE *model_file = fopen("weights_blob.bin", "rb");
RNNModel *model = rnnoise_model_from_file(model_file);
DenoiseState *st = rnnoise_create(model);

// Process audio...

rnnoise_destroy(st);
rnnoise_model_free(model);
fclose(model_file);  // Close only after freeing model
"""

```

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

### Export Weights to C Format

Source: https://github.com/xiph/rnnoise/blob/main/torch/weight-exchange/README.md

Routines for exporting model weights to C files are available in the 'exchange.c_export' module. This functionality is currently implemented for specific PyTorch layers like GRU, Linear, and Conv1d.

```python
import exchange.c_export

# Example usage (assuming a PyTorch model and writer instance)
# export_weights_to_c(model.gru, 'gru_weights.c')
# export_weights_to_c(model.linear, writer_instance)
```

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

### Load Custom Noise Suppression Model from File (C)

Source: https://context7.com/xiph/rnnoise/llms.txt

Loads a custom trained RNNoise model from a binary weights file specified by its filename. The loaded model must remain valid while the DenoiseState using it is active. This allows for using user-trained models.

```c
#include <stdio.h>
#include "rnnoise.h"

int main() {
    RNNModel *model;
    DenoiseState *st;

    // Load custom model from file
    model = rnnoise_model_from_filename("weights_blob.bin");
    if (model == NULL) {
        fprintf(stderr, "Failed to load model\n");
        return 1;
    }

    // Create denoise state with custom model
    st = rnnoise_create(model);
    if (st == NULL) {
        fprintf(stderr, "Failed to create denoise state\n");
        rnnoise_model_free(model);
        return 1;
    }

    // Process audio frames...

    // Clean up in correct order
    rnnoise_destroy(st);
    rnnoise_model_free(model);

    return 0;
}
```

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

### Train Custom RNNoise Model with PyTorch

Source: https://context7.com/xiph/rnnoise/llms.txt

Trains a new RNNoise model using generated features with PyTorch. This script supports custom architectures and hyperparameters. It requires training features as input and outputs checkpoint files to a specified directory. Key parameters include batch size, learning rate, epochs, and model architecture dimensions.

```python
#!/usr/bin/env python3
import sys
sys.path.append('./torch/rnnoise')

# Train model with custom parameters
# Command line usage:
"""
python3 train_rnnoise.py \
    training_features.f32 \
    output_models/ \
    --batch-size 128 \
    --lr 0.001 \
    --epochs 200 \
    --sequence-length 2000 \
    --cond-size 128 \
    --gru-size 384 \
    --gamma 0.25

# Training produces checkpoint files:
# output_models/checkpoints/rnnoise_1.pth
# output_models/checkpoints/rnnoise_2.pth
# ...
# output_models/checkpoints/rnnoise_200.pth

# Choose epoch with best validation performance
# Typically aim for ~75000 weight updates total
"""

```

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

### Process Audio Frame for Noise Suppression (C)

Source: https://context7.com/xiph/rnnoise/llms.txt

Processes a single frame of audio (480 samples) for noise reduction using the initialized RNNoise state. It takes input and output buffers of float samples and returns a voice activity detection probability. The processing can be done in-place.

```c
#include <stdio.h>
#include "rnnoise.h"

#define FRAME_SIZE 480

int main(int argc, char **argv) {
    FILE *f_input, *f_output;
    DenoiseState *st;
    float x[FRAME_SIZE];
    short tmp[FRAME_SIZE];
    int i;

    st = rnnoise_create(NULL);
    f_input = fopen("noisy_speech.raw", "rb");
    f_output = fopen("denoised_speech.raw", "wb");

    while (1) {
        // Read 16-bit PCM samples
        if (fread(tmp, sizeof(short), FRAME_SIZE, f_input) != FRAME_SIZE)
            break;

        // Convert to float
        for (i = 0; i < FRAME_SIZE; i++)
            x[i] = tmp[i];

        // Process frame (in-place processing supported)
        float vad_prob = rnnoise_process_frame(st, x, x);

        // Convert back to 16-bit
        for (i = 0; i < FRAME_SIZE; i++)
            tmp[i] = (short)x[i];

        fwrite(tmp, sizeof(short), FRAME_SIZE, f_output);
    }

    rnnoise_destroy(st);
    fclose(f_input);
    fclose(f_output);
    return 0;
}
```
Tokens:
Raw