Lb302.h

Go to the documentation of this file.

/*
 * Lb302.h - Incomplete Roland TB-303 bass synth emulation
 *
 * Copyright (c) 2006-2008 Paul Giblock <pgib/at/users.sourceforge.net>
 * Copyright (c) 2026 Fawn Sannar <rubiefawn/at/gmail.com>
 *
 * This file is part of LMMS - https://lmms.io
 *
 * Lb302FilterIIR2 is based on the gsyn filter code by Andy Sloane.
 *
 * Lb302Filter3Pole is based on the TB-303 instrument written by
 * Josep M Comajuncosas for the CSounds library
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program (see COPYING); if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 */
 
#ifndef LB302_H
#define LB302_H
 
#include <array>
#include <atomic>
#include <memory>
 
#include "Hardware.h"
#include "Instrument.h"
#include "InstrumentView.h"
#include "NotePlayHandle.h"
 
namespace lmms
{
 
namespace DspEffectLibrary { class Distortion; }
 
namespace gui
{
class AutomatableButtonGroup;
class Knob;
class Lb302SynthView;
class LedCheckBox;
}
 
 
struct Lb302FilterKnobState
{
        float cutoff;
        float reso;
        float envmod;
        float envdecay;
        float dist;
};
 
 
class Lb302Filter
{
public:
        Lb302Filter(Lb302FilterKnobState* p_fs) : fs{p_fs} {};
        virtual ~Lb302Filter() = default;
 
        virtual void recalc();
        virtual void envRecalc();
        virtual void playNote();
        virtual sample_t process(sample_t samp) = 0;
 
protected:
        Lb302FilterKnobState *fs;
 
        // Filter Decay
        struct
        {
                float c0 = 0.f; 
                std::array<float, 2> e = {0.f, 0.f}; 
                float resCoeff; 
        } m_vcf;
};
 
 
class Lb302FilterIIR2 : public Lb302Filter
{
public:
        Lb302FilterIIR2(Lb302FilterKnobState* p_fs);
 
        void recalc() override;
        void envRecalc() override;
        sample_t process(sample_t samp) override;
 
protected:
        struct
        {
                std::array<float, 2> d = {0.f, 0.f};
 
                // IIR2 Coefficients for mixing dry and delay. Mixing coefficients for the final sound.
                float a = 0.f;
                float b = 0.f;
                float c = 1.f;
        } m_iir2;
 
        std::unique_ptr<DspEffectLibrary::Distortion> m_dist;
};
 
 
class Lb302Filter3Pole : public Lb302Filter
{
public:
        Lb302Filter3Pole(Lb302FilterKnobState* p_fs) : Lb302Filter(p_fs) { envRecalc(); };
 
        void envRecalc() override;
        void recalc() override;
        sample_t process(sample_t samp) override;
 
protected:
        float m_kfcn;
        float m_kp;
        float m_kp1h; 
        float m_kres;
        std::array<sample_t, 3> m_ay = { 0.f, 0.f, 0.f };
        float m_lastin = 0.f;
        float m_value;
};
 
 
class Lb302Synth : public Instrument
{
        Q_OBJECT
        friend class gui::Lb302SynthView;
 
public:
        Lb302Synth(InstrumentTrack*);
        void play(SampleFrame* working_buffer) override;
        void playNote(NotePlayHandle* nph, SampleFrame* working_buffer) override;
        void deleteNotePluginData(NotePlayHandle* nph) override;
        void saveSettings(QDomDocument& doc, QDomElement& el) override;
        void loadSettings(const QDomElement& el) override;
        QString nodeName() const override;
        gui::PluginView* instantiateView(QWidget* parent) override;
 
public slots:
        void filterChanged();

        void decayChanged();
 
        void db24Toggled();
 
private:
        void processNote(NotePlayHandle* nph);
        void process(SampleFrame* outbuf, const f_cnt_t size);
        void recalcFilter();
 
        enum class VcoShape { Sawtooth, Triangle, Square, RoundSquare, Moog, Sine, Exponential, WhiteNoise,
                BLSawtooth, BLSquare, BLTriangle, BLMoog };
        enum class VcaMode { Attack, Decay, Idle, NeverPlayed };
 
        static constexpr float   s_distRatio = 4.f;
        static constexpr f_cnt_t s_envInc = 64; 
        static constexpr float   s_vcaAttack = 1.f - 0.96406088f; 
        static constexpr float   s_vcaInitial = 0.5f; 
 
        FloatModel m_vcfCutKnob;
        FloatModel m_vcfResKnob;
        FloatModel m_vcfModKnob;
        FloatModel m_vcfDecKnob;
        FloatModel m_vcoDetuneKnob;
 
        FloatModel m_distKnob;
        IntModel m_waveShape;
        FloatModel m_slideDecKnob;
 
        BoolModel m_slideToggle;
        BoolModel m_accentToggle;
        BoolModel m_deadToggle;
        BoolModel m_db24Toggle;
 
        // Oscillator
        float m_vcoInc = 0.f; 
        float m_vcoK = 0.f;   
        float m_vcoC = 0.f;   
 
        bool  m_newFreq = false;
        float m_trueFreq = 0.f;
        float m_slide = 0.f;     
        float m_slideInc = 0.f;  
        float m_slideBase = 0.f; 
 
        VcoShape m_vcoShape = VcoShape::BLSawtooth;
 
        // User settings
        Lb302FilterKnobState m_fs = {};
 
        std::array<std::unique_ptr<Lb302Filter>, 2> m_vcfs; 

        Lb302Filter& vcf() { return *m_vcfs[m_db24Toggle.value()]; }
 
        f_cnt_t m_vcfEnvPos = s_envInc; 
        f_cnt_t m_releaseFrame = 0;
 
        // Envelope State
        float m_vca = 0.f; 
        float m_noteVolume = 1.f; 
        panning_t m_notePan = DefaultPanning; 
        VcaMode m_vcaMode = VcaMode::NeverPlayed;
 
        NotePlayHandle* m_playingNote = nullptr;

        static constexpr std::size_t s_maxPendingNotes = 128;
        static_assert(std::has_single_bit(s_maxPendingNotes)); // s_maxPendingNotes MUST be a power of 2

        static constexpr std::size_t s_maxNoteEnqueueRetries = s_maxPendingNotes;

        static constexpr std::size_t s_notesBufMask = s_maxPendingNotes - 1;

        std::array<NotePlayHandle*, s_maxPendingNotes> m_notes {};

        alignas(hardware_destructive_interference_size) std::atomic_size_t m_notesReadSeq {0};

        alignas(hardware_destructive_interference_size) std::atomic_size_t m_notesWriteCommitted {0};

        alignas(hardware_destructive_interference_size) std::atomic_size_t m_notesWriteClaimed {0};
};
 
 
namespace gui
{
 
 
class Lb302SynthView : public InstrumentViewFixedSize
{
        Q_OBJECT
 
public:
        Lb302SynthView(Instrument* instrument, QWidget* parent);
        ~Lb302SynthView() override = default;
 
private:
        void modelChanged() override;
 
        Knob* m_vcfCutKnob;
        Knob* m_vcfResKnob;
        Knob* m_vcfDecKnob;
        Knob* m_vcfModKnob;
 
        Knob* m_distKnob;
        Knob* m_slideDecKnob;
        AutomatableButtonGroup* m_waveBtnGrp;
 
        LedCheckBox* m_slideToggle;
        // LedCheckBox* m_accentToggle; // TODO: implement accent notes
        LedCheckBox* m_deadToggle;
        LedCheckBox* m_db24Toggle;
};
 
 
} // namespace gui
 
} // namespace lmms
 
#endif // LB302_H