interpolate.hpp

Go to the documentation of this file.

// sbl/dsp/interpolate.hpp — Interpolation and blending utilities
//
// Named functions for common DSP operations that are trivial to write
// inline but benefit from standardized, readable names.
//
// Usage:
//   float mix = sbl::dsp::crossfade(dry, wet, 0.5f);    // 50/50 blend
//   float smooth = sbl::dsp::smooth_step(t);             // S-curve [0,1]
 
#pragma once
 
#include <cstdint>
#include <cmath>
 
namespace sbl::dsp {
 
/**
 * @brief Linear crossfade between two values
 *
 * @param a Value at t=0
 * @param b Value at t=1
 * @param t Blend factor [0.0, 1.0]
 * @return a + (b - a) * t
 */
inline constexpr float crossfade(float a, float b, float t) {
    return a + (b - a) * t;
}
 
/**
 * @brief Hermite smooth step (3rd-order S-curve)
 *
 * Maps [0, 1] → [0, 1] with zero derivative at endpoints.
 * Useful for equal-power-like crossfade curves, smooth transitions,
 * and perceptually linear parameter morphing.
 *
 * @param t Input [0.0, 1.0] (not clamped)
 * @return t² × (3 - 2t)
 */
inline constexpr float smooth_step(float t) {
    return t * t * (3.0f - 2.0f * t);
}
 
/**
 * @brief Integer crossfade for 16-bit values
 *
 * @param a Value at t=0
 * @param b Value at t=1
 * @param t Blend factor [0, 65535] (0 = all a, 65535 = all b)
 * @return Blended value
 */
inline constexpr int32_t crossfade_i16(int16_t a, int16_t b, uint16_t t) {
    return a + ((static_cast<int32_t>(b) - a) * t) / 65535;
}
 
// ─── Equal-power crossfade ───────────────────────────────────────────
 
/**
 * @brief Equal-power crossfade between two values
 *
 * Maintains constant power across the fade (no dip at t=0.5).
 * Uses sqrt approximation: a*sqrt(1-t) + b*sqrt(t).
 *
 * @param a Value at t=0 (dry)
 * @param b Value at t=1 (wet)
 * @param t Blend factor [0.0, 1.0]
 */
inline float crossfade_equal_power(float a, float b, float t) {
    return a * sqrtf(1.0f - t) + b * sqrtf(t);
}
 
// ─── Block crossfade (constant mix) ─────────────────────────────────
 
/**
 * @brief Linear crossfade over a block with constant mix
 *
 * out[i] = a[i] * (1-mix) + b[i] * mix. In-place safe (out can alias a or b).
 */
inline void crossfade_block(const float* a, const float* b,
                            float* out, float mix, uint16_t frames) {
    const float ga = 1.0f - mix;
    for (uint16_t i = 0; i < frames; ++i) {
        out[i] = a[i] * ga + b[i] * mix;
    }
}
 
/**
 * @brief Equal-power crossfade over a block with constant mix
 *
 * out[i] = a[i] * sqrt(1-mix) + b[i] * sqrt(mix). Gains computed once.
 */
inline void crossfade_block_equal_power(const float* a, const float* b,
                                        float* out, float mix, uint16_t frames) {
    const float ga = sqrtf(1.0f - mix);
    const float gb = sqrtf(mix);
    for (uint16_t i = 0; i < frames; ++i) {
        out[i] = a[i] * ga + b[i] * gb;
    }
}
 
} // namespace sbl::dsp