synth.hpp

/*
    synth.hpp - Support file for writing LV2 tone generating plugins in C++
    Copyright (C) 2007 Lars Luthman <lars.luthman@gmail.com>

    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 3 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; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 01222-1307  USA
 */
#ifndef LVTK_SYNTH_HPP
#define LVTK_SYNTH_HPP

#include <cmath>
#include <cstring>
#include <vector>

#include <lvtk/plugin.hpp>

namespace lvtk {

    using std::vector;

    static const unsigned char INVALID_KEY = 255;


    static inline float key2hz(unsigned char key) {
        return 440.0f * std::pow(2.0f, (key - 69) / 12.0f);
    }


    class Voice {
    public:

        void on(unsigned char key, unsigned char velocity) { }

        void off(unsigned char velocity) { }

        unsigned char get_key() const { return lvtk::INVALID_KEY; }

        void render(uint32_t from, uint32_t to) { }

        void set_port_buffers(vector<void*>& ports) { m_ports = &ports; }

    protected:

        template <typename T> inline T*& p(uint32_t port) {
            return reinterpret_cast<T*&>((*m_ports)[port]);
        }

        float*& p(uint32_t port) {
            return reinterpret_cast<float*&>((*m_ports)[port]);
        }

        vector<void*>* m_ports;
    };


    template <class V, class D,
              class Ext1 = end, class Ext2 = end, class Ext3 = end,
              class Ext4 = end, class Ext5 = end, class Ext6 = end,
              class Ext7 = end>
    class Synth : public Plugin<D, URID<true>, Ext1, Ext2, Ext3, Ext4, Ext5, Ext6, Ext7>
    {
    public:

        typedef Plugin<D, URID<true>, Ext1, Ext2, Ext3, Ext4, Ext5, Ext6, Ext7>
        Parent;

        Synth(uint32_t ports, uint32_t midi_input)
        : Parent(ports),
          m_midi_input (midi_input)
        {
            m_midi_type = Parent::map (LV2_MIDI__MidiEvent);
        }


        ~Synth()
        {
            for (unsigned i = 0; i < m_voices.size(); ++i)
                delete m_voices[i];
        }

        unsigned
        find_free_voice(unsigned char key, unsigned char velocity)
        {
            for (unsigned i = 0; i < m_voices.size(); ++i)
            {
                if (m_voices[i]->get_key() == lvtk::INVALID_KEY)
                    return i;
            }

            return 0;
        }


        void
        handle_midi (uint32_t size, unsigned char* data)
        {
            if (size != 3) return;
            LV2_Midi_Message_Type type (lv2_midi_message_type (data));

            if (data[0] == 0x90)
            {
                unsigned voice =
                        static_cast<D*>(this)->find_free_voice(data[1], data[2]);
                if (voice < m_voices.size())
                    m_voices[voice]->on(data[1], data[2]);
            }
            else if (data[0] == 0x80)
            {
                for (unsigned i = 0; i < m_voices.size(); ++i)
                {
                    if (m_voices[i]->get_key() == data[1])
                    {
                        m_voices[i]->off(data[2]);
                        break;
                    }
                }
            }
        }

        void
        handle_atom_event (LV2_Atom_Event* ev) { }

        void
        pre_process(uint32_t from, uint32_t to)
        { }


        void
        post_process(uint32_t from, uint32_t to)
        {  }


        void
        run(uint32_t sample_count)
        {
            D* synth = static_cast<D*>(this);

            // Zero output buffers so voices can add to them
            for (unsigned i = 0; i < m_audio_ports.size(); ++i)
                std::memset(p(m_audio_ports[i]), 0, sizeof(float) * sample_count);

            // Make the port buffers available to the voices
            for (unsigned i = 0; i < m_voices.size(); ++i)
                m_voices[i]->set_port_buffers(Parent::m_ports);

            const LV2_Atom_Sequence* seq = p<LV2_Atom_Sequence> (m_midi_input);
            uint32_t last_frame = 0;

            for (LV2_Atom_Event* ev = lv2_atom_sequence_begin (&seq->body);
                 !lv2_atom_sequence_is_end(&seq->body, seq->atom.size, ev);
                 ev = lv2_atom_sequence_next (ev))
            {
               synth->pre_process (last_frame, ev->time.frames);
               for (uint32_t i = 0; i < m_voices.size(); ++i)
                  m_voices[i]->render (last_frame, ev->time.frames);
               synth->post_process (last_frame, ev->time.frames);

               if (ev->body.type == m_midi_type)
                  synth->handle_midi (ev->body.size, (uint8_t*) LV2_ATOM_BODY (&ev->body));
               else
                  synth->handle_atom_event (ev);

               last_frame = ev->time.frames;
            }

            if (last_frame < sample_count)
            {
               synth->pre_process (last_frame, sample_count);
               for (uint32_t i = 0; i < m_voices.size(); ++i)
                  m_voices[i]->render (last_frame, sample_count);
               synth->post_process (last_frame, sample_count);
            }
        }


        void
        add_audio_outputs(uint32_t p1 = -1, uint32_t p2 = -1,
                          uint32_t p3 = -1, uint32_t p4 = -1,
                          uint32_t p5 = -1, uint32_t p6 = -1)
        {
            if (p1 == uint32_t(-1))
                return;
            m_audio_ports.push_back(p1);
            if (p2 == uint32_t(-1))
                return;
            m_audio_ports.push_back(p2);
            if (p3 == uint32_t(-1))
                return;
            m_audio_ports.push_back(p3);
            if (p4 == uint32_t(-1))
                return;
            m_audio_ports.push_back(p4);
            if (p5 == uint32_t(-1))
                return;
            m_audio_ports.push_back(p5);
            if (p6 == uint32_t(-1))
                return;
            m_audio_ports.push_back(p6);
        }


        void add_voices(V* v01 = 0, V* v02 = 0, V* v03 = 0, V* v04 = 0, V* v05 = 0,
                        V* v06 = 0, V* v07 = 0, V* v08 = 0, V* v09 = 0, V* v10 = 0,
                        V* v11 = 0, V* v12 = 0, V* v13 = 0, V* v14 = 0, V* v15 = 0,
                        V* v16 = 0, V* v17 = 0, V* v18 = 0, V* v19 = 0, V* v20 = 0)
        {
            if (v01 == 0)
                return;
            m_voices.push_back(v01);
            if (v02 == 0)
                return;
            m_voices.push_back(v02);
            if (v03 == 0)
                return;
            m_voices.push_back(v03);
            if (v04 == 0)
                return;
            m_voices.push_back(v04);
            if (v05 == 0)
                return;
            m_voices.push_back(v05);
            if (v06 == 0)
                return;
            m_voices.push_back(v06);
            if (v07 == 0)
                return;
            m_voices.push_back(v07);
            if (v08 == 0)
                return;
            m_voices.push_back(v08);
            if (v09 == 0)
                return;
            m_voices.push_back(v09);
            if (v10 == 0)
                return;
            m_voices.push_back(v10);
            if (v11 == 0)
                return;
            m_voices.push_back(v11);
            if (v12 == 0)
                return;
            m_voices.push_back(v12);
            if (v13 == 0)
                return;
            m_voices.push_back(v13);
            if (v14 == 0)
                return;
            m_voices.push_back(v14);
            if (v15 == 0)
                return;
            m_voices.push_back(v15);
            if (v16 == 0)
                return;
            m_voices.push_back(v16);
            if (v17 == 0)
                return;
            m_voices.push_back(v17);
            if (v18 == 0)
                return;
            m_voices.push_back(v18);
            if (v19 == 0)
                return;
            m_voices.push_back(v19);
            if (v20 == 0)
                return;
            m_voices.push_back(v20);
        }
    protected:

        template <typename T> T*&
        p(uint32_t port) {
            return reinterpret_cast<T*&>(Parent::m_ports[port]);
        }

        float*&
        p(uint32_t port) {
            return reinterpret_cast<float*&>(Parent::m_ports[port]);
        }

        vector<V*> m_voices;

        vector<uint32_t> m_audio_ports;

        uint32_t m_midi_input;

        LV2_URID m_midi_type;

    };
}

#endif /* LVTK_SYNTH_HPP */