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.
 
#ifndef SBL_DSP_MATH_PITCH_HPP_
#define SBL_DSP_MATH_PITCH_HPP_
 
#include <cstdint>
 
#include <sbl/dsp/math/constants.hpp>
#include <sbl/dsp/tables/pitch_ratio_high_256.hpp>
#include <sbl/dsp/tables/pitch_ratio_low_256.hpp>
 
namespace sbl::dsp::math {
 
/// @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) {
    // ±10 octaves = ±120 semitones before folding
    constexpr float FOLD_RANGE = 120.0f;
    // 2^10 = 1024 (10 octaves)
    constexpr float FOLD_SCALE = 1024.0f;
    float scale = 1.0f;
    while (semitones > FOLD_RANGE) { semitones -= FOLD_RANGE; scale *= FOLD_SCALE; }
    while (semitones < -FOLD_RANGE) { semitones += FOLD_RANGE; scale *= (1.0f / FOLD_SCALE); }
    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 * PHASE_ACCUMULATOR_RANGE);
}
 
/// The pitch-su convention: a unipolar signal spans C1..C9 (MIDI 24..120),
/// the mapping MorphOsc set and every pitched widget follows.
inline constexpr float PITCH_SU_MIN_NOTE = 24.0f;
inline constexpr float PITCH_SU_MAX_NOTE = 120.0f;
inline constexpr float PITCH_SU_NOTE_RANGE = PITCH_SU_MAX_NOTE - PITCH_SU_MIN_NOTE;
 
inline constexpr float note_of_su(float su) { return PITCH_SU_MIN_NOTE + su * PITCH_SU_NOTE_RANGE; }
inline constexpr float su_of_note(float note) { return (note - PITCH_SU_MIN_NOTE) / PITCH_SU_NOTE_RANGE; }
 
} // namespace sbl::dsp::math
 
#endif // SBL_DSP_MATH_PITCH_HPP_