SmoothIR

KO | EN

gitlite — search

#javascript #python #hacktoberfest #react #ai #typescript #llm #go #golang #android #machine-learning #rust #deep-learning #linux

(★ 38)

Linear Phase EQ based on Impulse Response Processing

SmoothIR Latest Version Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# SmoothIR

**SmoothIR** is a tool for creating impulse responses (IRs) through spectral matching of two audio files  
– with a focus on **musically useful results**, stability, and predictable behavior.

**SmoothEQ** is a Linear Phase EQ based on Impulse Response Processing as Clap plugin.

The idea is simple:

> The spectral difference between a *Reference* and a *Source* is transformed into an IR  
> – then carefully shaped using EQ-style controls.

The result is an IR that behaves like a **well-tuned filter**, ideal for creative applications such as guitars, reamping, and sound design.

---

## Features

* Spectral matching (Reference vs. Source)
* Robust handling of missing inputs (Reference-only / Source-only modes)
* Minimum-phase IR generation with adjustable IR length
* **EQ-style low/high rolloff (true dB/oct behavior)**
* Continuous **Smooth** control for musical shaping
* Stable, deterministic processing (no heuristics, no randomness)
* Interactive spectrum UI with band-style workflow
* Zero-latency hybrid convolution engine (FIR head + FFT tail)
* Real-time safe processing suitable for plugin environments
* IR morphing / live updates without audio dropouts

---

## Processing Engine

SmoothIR uses a **hybrid convolution engine** designed for real-time audio use.

It combines:

* A **zero-latency FIR head** (time domain)
* A **partitioned FFT tail** (frequency domain)

This design ensures:

* Instant transient response (no delay on attack)
* Efficient processing of long impulse responses
* Stable CPU usage even with large IR sizes

In practice, this behaves as **true zero-latency processing**,  
while still supporting high-resolution filtering.

---

## IR Length

The **IR length** defines the duration of the generated impulse response and directly affects frequency resolution and low-frequency accuracy.

* **Longer IRs** → better low-end resolution and smoother matching  
* **Shorter IRs** → lower latency and CPU usage

Rule of thumb:

f_min ≈ sampleRate / IR_length

Practical ranges:

* 2048 samples → ~40–50 Hz  
* 4096 samples → ~25–30 Hz  
* 8192+ samples → recommended for deep low-end work

Frequencies below ~20 Hz are automatically de-emphasized to avoid instability and unnecessary energy.

---

## Usage

smoothir -r <reference.wav> -s <source.wav>

### Parameters

* `-r`, `--ref`  
  Reference file (target sound)

* `-s`, `--src`  
  Source file (input sound)

---

## Real-Time Interaction

SmoothIR is designed for interactive workflows:

* Immediate IR updates after parameter changes
* Click-free IR switching
* Stable behavior even under rapid parameter changes

This allows SmoothIR to behave like a real-time EQ,
while internally operating on impulse responses.

## Sound Shaping

After spectral matching, the IR is shaped in a controlled and predictable way.

## Spectral EQ Concept

SmoothIR can also be understood as a **spectral EQ built on impulse responses**.

Instead of stacking traditional filter stages:

> The entire EQ curve is embedded into a single minimum-phase IR

This approach provides:

* Perfectly smooth phase behavior
* No filter interaction artifacts
* Extremely natural tonal shaping

All band adjustments (frequency, gain, Q) directly modify the spectral target,
which is then converted into a coherent IR.

This results in:

> EQ behavior that feels continuous, stable, and highly musical

### Low / High Cut (EQ-style)

SmoothIR uses a **true EQ-like rolloff**:

* Defined in **dB per octave**
* Monotonic and stable (no low-end rebound, no ripple)
* Comparable to analog-style highpass/lowpass filters (Butterworth-like)

This ensures:

* Clean low-end (no rumble buildup)  
* Smooth high-end (no harsh fizz)  
* No unexpected spectral artifacts

---

### Smooth

A continuous control for spectral smoothing:

* `0.0` → maximum detail transfer  
* `~0.2 – 0.4` → musical sweet spot  
* `1.0` → heavily smoothed

Internally:

> The raw transfer function is blended with a smoothed version  
> → preserving tone while removing narrow resonances and noise

---

## Analysis Modes

SmoothIR behaves robustly depending on available inputs:

* **Reference + Source** → full spectral matching  
* **Reference only** →  visualize the Reference spectrum
* **Source only** → spectrum capture

Missing inputs do **not** produce undefined behavior.

---

## UI / Interaction (EQ-style Workflow)

SmoothIR follows a modern parametric EQ interaction model:

* **Drag & Drop Bands**
  * Up / Down → Gain  
  * Left / Right → Frequency

* **Mouse Wheel**
  * Adjusts **Q (bandwidth)**

* Immediate visual feedback via spectrum display  
* Band-oriented workflow similar to professional EQs

Goal:

> Make IR creation feel like working with an EQ – not a black box

---

## Typical Workflow

1. Load Reference and Source  
2. Generate IR  
3. Set Low/High Cut (define usable range)  
4. Adjust bands (freq / gain / Q)  
5. Dial in Smooth  
6. Apply IR

---

## Notes

* Extreme low/high frequencies often contain little usable information  
  → controlled rolloff improves stability and sound quality

* Over-smoothing removes character  
  → use moderately

* The generated IR is **minimum-phase**
  → efficient, phase-coherent, and optimized for zero-latency convolution

---

## Example

A creative use case:

* Reference: Piano  
* Source: Harp  
* Applied to: Guitar

→ produces a unique but still musical tonal character

---

## Dependencies

SmoothIR relies on a small set of widely available libraries:

* **X11** – windowing (Linux)  
* **cairo** – UI rendering  
* **libsndfile** – audio I/O  
* **FFTW3** – spectral processing  
* **jackd** – real-time audio

### Install (Debian/Ubuntu)

sudo apt install libx11-dev libcairo2-dev libsndfile1-dev libfftw3-dev libjack-jackd2-dev

---

## Build

git clone https://github.com/brummer10/SmoothIR.git
    cd SmoothIR
    git submodule init
    git submodule update
    make
    sudo make install

## Build as Clap plugin

make clap
    make install

---

## Concept

SmoothIR deliberately avoids:

* heuristic corrections  
* unstable spectral tricks  
* artificial post-processing

Instead:

> Clear separation of **analysis → shaping → synthesis**

Resulting in predictable, reproducible, and musical behavior.

---

## License

BSD-3-Clause

---

## Philosophy

> If it sounds good, it is right.

SmoothIR

SmoothIR Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

SmoothIR

SmoothIR Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Download README