lv2synth.hpp

/****************************************************************************
    
    lv2synth.hpp - support file for writing LV2 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 LV2SYNTH_HPP
#define LV2SYNTH_HPP

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

#include <lv2plugin.hpp>
#include <lv2_event_helpers.h>


namespace LV2 {
  
  static const unsigned char INVALID_KEY = 255;
  
  
  static inline float key2hz(unsigned char key) {
    return 8.1758 * std::pow(1.0594, key);
  }
  
  
  class Voice {
  public:
    
    void on(unsigned char key, unsigned char velocity) { }
    
    void off(unsigned char velocity) { }
    
    unsigned char get_key() const { return LV2::INVALID_KEY; }
    
    void render(uint32_t from, uint32_t to) { }
    
    void set_port_buffers(std::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]);
    }
    
    std::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, URIMap<true>,
                              Ext1, Ext2, Ext3, Ext4, Ext5, Ext6, Ext7> {
  public:
    
    typedef Plugin<D, URIMap<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::uri_to_id(LV2_EVENT_URI,
                          "http://lv2plug.in/ns/ext/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() == INVALID_KEY)
          return i;
      }
      return 0;
    }
    
    
    void handle_midi(uint32_t size, unsigned char* data) {
      if (size != 3)
        return;
      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 pre_process(uint32_t from, uint32_t to) {

    }
    
    
    void post_process(uint32_t from, uint32_t to) {

    }
    
    
    void run(uint32_t sample_count) {
      
      // 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);
      
      LV2_Event_Iterator iter;
      lv2_event_begin(&iter, p<LV2_Event_Buffer>(m_midi_input));
      
      uint8_t* event_data;
      uint32_t samples_done = 0;
      
      while (samples_done < sample_count) {
        uint32_t to = sample_count;
        LV2_Event* ev = 0;
        if (lv2_event_is_valid(&iter)) {
          ev = lv2_event_get(&iter, &event_data);
          to = ev->frames;
          lv2_event_increment(&iter);
        }
        if (to > samples_done) {
          static_cast<D*>(this)->pre_process(samples_done, to);
          for (unsigned i = 0; i < m_voices.size(); ++i)
            m_voices[i]->render(samples_done, to);
          static_cast<D*>(this)->post_process(samples_done, to);
          samples_done = to;
        }
        
        /* This is what we do with events:
           - if it's a MIDI event, pass it to handle_midi()
           - if it's something else, just ignore it (it's safe)
        */
        if (ev) {
          if (ev->type == m_midi_type)
            static_cast<D*>(this)->handle_midi(ev->size, event_data);
        }
      }
      
    }
    
    
    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]);
    }


    std::vector<V*> m_voices;
    
    std::vector<uint32_t> m_audio_ports;
    
    uint32_t m_midi_input;
    
    uint32_t m_midi_type;
    
  };
  
}


#endif