channel.hpp

Go to the documentation of this file.

// sbl/dsp/widgets/channel.hpp — Mixer channel strip (Audio Stack — Widgets)
//
// Composes Fader + Pan + Sends into a self-contained channel strip. Each
// channel owns its audio buffers, fader gain, stereo pan, and send routing.
// The Mixer module composes multiple Channels for summing and master output.
//
// Front side (application writes):
//   write_input_mono(src, n)         — write mono source into channel
//   write_input_stereo(src_l, src_r, n) — write stereo source into channel
//   set_gain_su(float)              — [0,1] channel fader level
//   set_pan_su(float)               — [0,1] pan position (0=L, 0.5=center, 1=R)
//   set_send_level_su(idx, float)   — [0,1] send amount
//
// Back side (mixer reads after process()):
//   post_l() / post_r()             — post-gain, post-pan stereo output
//   buf_l / buf_r                   — raw input (pre-pan, pre-fader) for sends
//
// process(n) applies the full channel strip:
//   1. Mono spread (copy L to R if mono)
//   2. Fader gain + pan → post_l_/post_r_
//   buf_l/buf_r are NOT modified — they stay as pre-pan, pre-fader source for sends.
//
// Send routing:
//   Sends tap from buf_l/buf_r (always pre-pan). Gain is either:
//     PreFader:  send_level only
//     PostFader: fader_gain * send_level
//   Pan only affects the master bus sum via post_l/post_r. This matches
//   real console behavior where sends are mono taps before the pan pot.
//
// Usage:
//   sbl::dsp::widgets::Channel<48, 2> ch;
//   ch.set_format(Format::Mono);
//   ch.add_send(0, 0.3f);                    // send to return 0 at 30%
//   ch.set_gain_su(0.8f);
//   ch.set_pan_su(0.5f);                     // center
//   ch.write_input_mono(voice_buf, n);
//   ch.process(n);
//   // Mixer reads ch.post_l(), ch.post_r() for master summing
//   // Mixer reads ch.buf_l, ch.buf_r for send routing
 
#ifndef SBL_DSP_WIDGETS_CHANNEL_HPP_
#define SBL_DSP_WIDGETS_CHANNEL_HPP_
 
#include <cstdint>
 
#include <sbl/dsp/comp/fader.hpp>
#include <sbl/dsp/comp/pan.hpp>
 
namespace sbl::dsp::widgets {
 
enum class Format : uint8_t {
    Mono,    // L buffer only, copied to R on process()
    Stereo,  // Independent L/R buffers
};
 
enum class SendType : uint8_t {
    PostFader,   // signal * fader * send_level (Ableton default)
    PreFader,    // signal * send_level (ignores channel fader)
};
 
struct Send {
    uint8_t target = 0;        // return channel index
    comp::Fader level;         // send amount with smoothing
    SendType type = SendType::PostFader;
};
 
template <uint16_t MaxFrames, uint8_t MaxSends = 4>
class Channel {
public:
    // Input buffers — written via write_input_*, read by mixer for sends.
    // These are the raw, pre-pan, pre-fader signal. NOT modified by process().
    float buf_l[MaxFrames] = {};
    float buf_r[MaxFrames] = {};
 
    // ── Front side: input ─────────────────────────────────────────────
 
    /// Write mono input — channel spreads to both L/R on process().
    void write_input_mono(const float* src, uint16_t n) {
        for (uint16_t i = 0; i < n; ++i)
            buf_l[i] = src[i];
    }
 
    /// Write stereo input.
    void write_input_stereo(const float* src_l, const float* src_r, uint16_t n) {
        for (uint16_t i = 0; i < n; ++i) {
            buf_l[i] = src_l[i];
            buf_r[i] = src_r[i];
        }
    }
 
    // ── Ports ────────────────────────────────────────────────────────
 
    /// Port: channel gain level [0,1].
    void set_gain_su(float su) { fader_.set_level_su(su); }
 
    /// Port: pan position [0,1]. 0=L, 0.5=center, 1=R.
    void set_pan_su(float su) { pan_.set_position_su(su); }
 
    /// Port: send level [0,1] for send at index.
    void set_send_level_su(uint8_t send_index, float su) {
        if (send_index < send_count_) {
            sends_[send_index].level.set_level_su(su);
        }
    }
 
    // ── Parameters ───────────────────────────────────────────────────
 
    void set_format(Format f) { format_ = f; }
    void set_mute(bool m) { mute_ = m; }
    void set_solo(bool s) { solo_ = s; }
    void set_fader_taper(comp::Taper t) { fader_.set_taper(t); }
 
    // ── Send configuration ───────────────────────────────────────────
 
    /// Configure a send at init time. Default taper is Audio for send faders.
    void add_send(uint8_t target, float initial_level,
                  SendType type = SendType::PostFader) {
        if (send_count_ < MaxSends) {
            Send& s = sends_[send_count_++];
            s.target = target;
            s.type = type;
            s.level.set_taper(comp::Taper::Audio);
            s.level.set_level_su(initial_level);
        }
    }
 
    // ── Processing ───────────────────────────────────────────────────
 
    /// Process the full channel strip: mono spread, fader gain, pan.
    /// After this call, post_l()/post_r() contain the master-ready output.
    /// buf_l/buf_r remain unmodified (pre-pan, pre-fader) for send routing.
    void process(uint16_t n) {
        // Mono spread: copy L to R so both buffers are valid
        if (format_ == Format::Mono) {
            for (uint16_t i = 0; i < n; ++i)
                buf_r[i] = buf_l[i];
        }
 
        // Apply fader gain to produce post-fader output. The smoother
        // advances by the full block; the gain is block-constant.
        float gain = fader_.tick(n);
        for (uint16_t i = 0; i < n; ++i) {
            post_l_[i] = buf_l[i] * gain;
            post_r_[i] = buf_r[i] * gain;
        }
 
        // Apply pan in-place on post buffers
        pan_.process(post_l_, post_r_, n);
    }
 
    // ── Back side: mixer reads these after process() ─────────────────
 
    const float* post_l() const { return post_l_; }
    const float* post_r() const { return post_r_; }
 
    // ── Accessors ────────────────────────────────────────────────────
 
    float fader_gain() const { return fader_.gain(); }
    bool muted() const { return mute_; }
    bool soloed() const { return solo_; }
    Format format() const { return format_; }
    uint8_t send_count() const { return send_count_; }
    const Send& send(uint8_t i) const { return sends_[i]; }
    Send& send(uint8_t i) { return sends_[i]; }
 
    comp::Fader& fader() { return fader_; }
    comp::Pan& pan() { return pan_; }
 
private:
    comp::Fader fader_;        // channel level
    comp::Pan pan_;            // stereo placement
    Send sends_[MaxSends] = {};
    uint8_t send_count_ = 0;
    Format format_ = Format::Mono;
    bool mute_ = false;
    bool solo_ = false;
 
    // Post-gain, post-pan output buffers (master-ready)
    float post_l_[MaxFrames] = {};
    float post_r_[MaxFrames] = {};
};
 
} // namespace sbl::dsp::widgets
 
#endif // SBL_DSP_WIDGETS_CHANNEL_HPP_