pitch.hpp

Go to the documentation of this file.

// sbl/dsp/pitch.hpp — Semitone-to-frequency-ratio conversion
//
// Two-table multiplication approach: split 2^(semitones/12) into coarse
// (per-semitone) and fine (sub-semitone) tables.  2^(a+b) = 2^a * 2^b.
// Cost: 1 float multiply + table lookups. ~2KB flash, <0.4 cent error.
//
// Adapted from Mutable Instruments stmlib/dsp/units.h (MIT license).
//
// Note: Requires hardware FPU. STM32H7 (Cortex-M7) and RP2350 (Cortex-M33)
// have FPU — fine. RP2040 (Cortex-M0+) does not — avoid on M0+ targets.
 
#pragma once
 
#include <cstdint>
 
#include <sbl/dsp/tables/pitch_ratio_high_256.hpp>
#include <sbl/dsp/tables/pitch_ratio_low_256.hpp>
 
namespace sbl::dsp {
 
/// @note All functions in sbl::dsp (pitch) are ISR-safe — bounded computation, no I/O.
 
/// Convert semitones to frequency ratio using two-table multiplication.
/// Input range: -128.0 to +127.0 semitones. 0 = unison (ratio 1.0).
/// Cost: 1 float multiply + table lookups.
inline float semitones_to_ratio(float semitones) {
    float pitch = semitones + 128.0f;
    int32_t integral = static_cast<int32_t>(pitch);
    float fractional = pitch - static_cast<float>(integral);
    if (integral < 0) integral = 0;
    if (integral > 255) integral = 255;
    return lut::pitch_ratio_high_256[integral] *
           lut::pitch_ratio_low_256[static_cast<int32_t>(fractional * 256.0f)];
}
 
/// Extended range version — handles semitones outside [-128, 127].
/// Uses octave doubling/halving for extreme values.
inline float semitones_to_ratio_safe(float semitones) {
    float scale = 1.0f;
    while (semitones > 120.0f) { semitones -= 120.0f; scale *= 1024.0f; }
    while (semitones < -120.0f) { semitones += 120.0f; scale *= (1.0f / 1024.0f); }
    return scale * semitones_to_ratio(semitones);
}
 
/// MIDI note to frequency ratio relative to A4 (note 69).
/// note_to_ratio(69) = 1.0, note_to_ratio(81) = 2.0.
inline float note_to_ratio(float midi_note) {
    return semitones_to_ratio(midi_note - 69.0f);
}
 
/// MIDI note to frequency in Hz. A4 = 440 Hz.
inline float note_to_frequency(float midi_note) {
    return 440.0f * note_to_ratio(midi_note);
}
 
/// MIDI note to phase increment for a given sample rate.
/// phase_inc = freq / sample_rate * 2^32
inline uint32_t note_to_phase_increment(float midi_note, float sample_rate) {
    float freq = note_to_frequency(midi_note);
    return static_cast<uint32_t>(freq / sample_rate * 4294967296.0f);
}
 
/// Fast 2^x approximation via pitch tables. x in [-10.67, +10.58].
inline float exp2_approx(float x) {
    return semitones_to_ratio(x * 12.0f);
}
 
/// Extended range 2^x.
inline float exp2_approx_safe(float x) {
    return semitones_to_ratio_safe(x * 12.0f);
}
 
} // namespace sbl::dsp