cam.hpp

Go to the documentation of this file.

// sbl/control/cam.hpp — Cam profile evaluation
//
// Evaluates LUTE-generated cam transfer function tables.
// A cam table maps [0, 1] input to arbitrary float output via precomputed
// breakpoint-interpolated lookup tables.
//
// Rate-agnostic: works at control rate (200 Hz knob updates) or audio rate
// (48 kHz modulation reshaping). Cost is ~5-8 cycles per evaluation on M7.
//
// Usage:
//   #include <sbl/control/cam.hpp>
//   #include "davis_jr/cam/k4_delay_drive_256.hpp"
//
//   float v = sbl::control::cam_evaluate(
//       davis_jr::cam::k4_delay_drive_256, 256, knob_value);
 
#ifndef SBL_CONTROL_CAM_HPP_
#define SBL_CONTROL_CAM_HPP_
 
#include <cstdint>
 
namespace sbl::control {
 
/// Evaluate a cam table at a single input position.
/// Input clamped to [0, 1]. Returns linearly interpolated table value.
/// Table must have at least 1 guard point (size + 1 entries).
inline float cam_evaluate(const float* table, uint16_t size, float input) {
    float clamped = input < 0.0f ? 0.0f : (input > 1.0f ? 1.0f : input);
    float pos = clamped * static_cast<float>(size - 1);
    uint16_t idx = static_cast<uint16_t>(pos);
    float frac = pos - static_cast<float>(idx);
    return table[idx] + (table[idx + 1] - table[idx]) * frac;
}
 
/// Evaluate a cam table across a buffer.
inline void cam_evaluate_block(const float* table, uint16_t size,
                               const float* in, float* out, uint16_t n) {
    for (uint16_t i = 0; i < n; ++i) {
        out[i] = cam_evaluate(table, size, in[i]);
    }
}
 
} // namespace sbl::control
 
#endif // SBL_CONTROL_CAM_HPP_