libraries/lv2plugin/lv2plugin.hpp

/****************************************************************************
    
    lv2plugin.hpp - support file for writing LV2 plugins in C++
    
    Copyright (C) 2006-2007 Lars Luthman <lars.luthman@gmail.com>
    Modified by Dave Robillard, 2008

    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 LV2PLUGIN_HPP
#define LV2PLUGIN_HPP

#include <cstdarg>

#include <cstring>
#include <string>
#include <vector>

#include <lv2.h>
#include <lv2_uri_map.h>
#include <lv2_saverestore.h>
#include <lv2_event.h>
#include <lv2_contexts.h>
#include <lv2types.hpp>


namespace LV2 {
  

  class DescList : public std::vector<LV2_Descriptor> {
  public:
    ~DescList();
  };


  DescList& get_lv2_descriptors();

  
  template <class Derived, 
            class Ext1 = End, class Ext2 = End, class Ext3 = End,
            class Ext4 = End, class Ext5 = End, class Ext6 = End, 
            class Ext7 = End, class Ext8 = End, class Ext9 = End>
  class Plugin : public MixinTree<Derived, 
                                  Ext1, Ext2, Ext3, Ext4, Ext5, 
                                  Ext6, Ext7, Ext8, Ext9> {
  public:
    
    Plugin(uint32_t ports) 
      : m_ports(ports, 0),
        m_ok(true) {
      m_features = s_features;
      m_bundle_path = s_bundle_path;
      s_features = 0;
      s_bundle_path = 0;
      if (m_features) {
        FeatureHandlerMap hmap;
        Derived::map_feature_handlers(hmap);
        for (const Feature* const* iter = m_features; *iter != 0; ++iter) {
          FeatureHandlerMap::iterator miter;
          miter = hmap.find((*iter)->URI);
          if (miter != hmap.end())
            miter->second(static_cast<Derived*>(this), (*iter)->data);
        }
      }
    }
    
    void connect_port(uint32_t port, void* data_location) {
      m_ports[port] = data_location;
    }
    
    void activate() { }
  
    void run(uint32_t sample_count) { }
  
    void deactivate() { }
    
    static unsigned register_class(const std::string& uri) {
      LV2_Descriptor desc;
      std::memset(&desc, 0, sizeof(LV2_Descriptor));
      char* c_uri = new char[uri.size() + 1];
      std::memcpy(c_uri, uri.c_str(), uri.size() + 1);
      desc.URI = c_uri;
      desc.instantiate = &Derived::_create_plugin_instance;
      desc.connect_port = &Derived::_connect_port;
      desc.activate = &Derived::_activate;
      desc.run = &Derived::_run;
      desc.deactivate = &Derived::_deactivate;
      desc.cleanup = &Derived::_delete_plugin_instance;
      desc.extension_data = &Derived::extension_data;
      get_lv2_descriptors().push_back(desc);
      return get_lv2_descriptors().size() - 1;
    }
    
    bool check_ok() {
      return m_ok && MixinTree<Derived, 
                               Ext1, Ext2, Ext3, Ext4, Ext5, 
                               Ext6, Ext7, Ext8, Ext9>::check_ok();
    }

  protected:
  
    template <typename T> T*& p(uint32_t port) {
      return reinterpret_cast<T*&>(m_ports[port]);
    }
  
    float*& p(uint32_t port) {
      return reinterpret_cast<float*&>(m_ports[port]);
    }
    
    const char* bundle_path() const {
      return m_bundle_path;
    }
    
    void set_ok(bool ok) {
      m_ok = ok;
    }
    
    std::vector<void*> m_ports;

  private:
    
    static void _connect_port(LV2_Handle instance, uint32_t port, 
                             void* data_location) {
      reinterpret_cast<Derived*>(instance)->connect_port(port, data_location);
    }
  
    static void _activate(LV2_Handle instance) {
      reinterpret_cast<Derived*>(instance)->activate();
    }
  
    static void _run(LV2_Handle instance, uint32_t sample_count) {
      reinterpret_cast<Derived*>(instance)->run(sample_count);
    }
  
    static void _deactivate(LV2_Handle instance) {
      reinterpret_cast<Derived*>(instance)->deactivate();
    }
  
    static LV2_Handle _create_plugin_instance(const LV2_Descriptor* descriptor,
                                              double sample_rate,
                                              const char* bundle_path,
                                              const Feature* const* 
                                              features) {

      // copy some data to static variables so the subclasses don't have to
      // bother with it
      s_features = features;
      s_bundle_path = bundle_path;

      Derived* t = new Derived(sample_rate);
      if (t->check_ok())
        return reinterpret_cast<LV2_Handle>(t);
      delete t;
      return 0;
    }
            
    static void _delete_plugin_instance(LV2_Handle instance) {
      delete reinterpret_cast<Derived*>(instance);
    }


  private:
    
    LV2::Feature const* const* m_features;
    
    char const* m_bundle_path;
    
    static LV2::Feature const* const* s_features;

    static char const* s_bundle_path;
    
    bool m_ok;

  };

  
  // The static variables need to be initialised. 
  template<class Derived, class Ext1, class Ext2, class Ext3, class Ext4,
           class Ext5, class Ext6, class Ext7, class Ext8, class Ext9>
  LV2::Feature const* const* 
  Plugin<Derived, Ext1, Ext2, Ext3, Ext4, 
         Ext5, Ext6, Ext7, Ext8, Ext9>::s_features = 0;
  
  template<class Derived, class Ext1, class Ext2, class Ext3, class Ext4,
           class Ext5, class Ext6, class Ext7, class Ext8, class Ext9>
  char const* 
  Plugin<Derived, Ext1, Ext2, Ext3, Ext4, 
         Ext5, Ext6, Ext7, Ext8, Ext9>::s_bundle_path = 0;

  
  template <bool Required = true>
  struct FixedBufSize {
    
    template <class Derived> struct I : Extension<Required> {
      
      I() : m_buffer_size(0) { }
      
      static void map_feature_handlers(FeatureHandlerMap& hmap) {
        hmap["http://tapas.affenbande.org/lv2/ext/fixed-buffersize"] = 
          &I<Derived>::handle_feature;
      }
      
      static void handle_feature(void* instance, void* data) { 
        Derived* d = reinterpret_cast<Derived*>(instance);
        I<Derived>* fe = static_cast<I<Derived>*>(d);
        fe->m_buffer_size = *reinterpret_cast<uint32_t*>(data);
        fe->m_ok = true;
      }
      
    protected:
      
      uint32_t get_buffer_size() const { return m_buffer_size; }
      
      uint32_t m_buffer_size;
      
    };
    
  };
  
  template <bool Required = true>
  struct FixedP2BufSize {
    
    template <class Derived> struct I : Extension<Required> {
      
      I() : m_buffer_size(0) { }
      
      static void map_feature_handlers(FeatureHandlerMap& hmap) {
        hmap["http://tapas.affenbande.org/lv2/ext/power-of-two-buffersize"] = 
          &I<Derived>::handle_feature;
      }
      
      static void handle_feature(void* instance, void* data) { 
        Derived* d = reinterpret_cast<Derived*>(instance);
        I<Derived>* fe = static_cast<I<Derived>*>(d);
        fe->m_buffer_size = *reinterpret_cast<uint32_t*>(data);
        fe->m_ok = true;
      }
      
    protected:
      
      uint32_t get_buffer_size() const { return m_buffer_size; }
      
      uint32_t m_buffer_size;
      
    };
  
  };


  template <bool Required = true>
  struct SaveRestore {
    
    template <class Derived> struct I : Extension<Required> {
      
      I() { }
      
      static void map_feature_handlers(FeatureHandlerMap& hmap) {
        hmap[LV2_SAVERESTORE_URI] = &I<Derived>::handle_feature;
      }
      
      static void handle_feature(void* instance, void* data) { 
        Derived* d = reinterpret_cast<Derived*>(instance);
        I<Derived>* fe = static_cast<I<Derived>*>(d);
        fe->m_ok = true;
      }
      
      static const void* extension_data(const char* uri) { 
        if (!std::strcmp(uri, LV2_SAVERESTORE_URI)) {
          static LV2SR_Descriptor srdesc = { &I<Derived>::_save,
                                             &I<Derived>::_restore };
          return &srdesc;
        }
        return 0;
      }
      
      char* save(const char* directory, LV2SR_File*** files) { return 0; }
      
      char* restore(const LV2SR_File** files) { return 0; }
      
    protected:
      
      static char* _save(LV2_Handle h, 
                         const char* directory, LV2SR_File*** files) {
        return reinterpret_cast<Derived*>(h)->save(directory, files);
      }
      
      static char* _restore(LV2_Handle h, const LV2SR_File** files) {
        return reinterpret_cast<Derived*>(h)->restore(files);
      }
      
    };
  };
  
  
  template <bool Required = true>
  struct EventRef {
    
    template <class Derived> struct I : Extension<Required> {
      
      I() : m_callback_data(0), m_ref_func(0), m_unref_func(0) { }
      
      static void map_feature_handlers(FeatureHandlerMap& hmap) {
        hmap[LV2_EVENT_URI] = &I<Derived>::handle_feature;
      }
      
      static void handle_feature(void* instance, void* data) { 
        Derived* d = reinterpret_cast<Derived*>(instance);
        I<Derived>* fe = static_cast<I<Derived>*>(d);
        LV2_Event_Feature* ef = reinterpret_cast<LV2_Event_Feature*>(data);
        fe->m_callback_data = ef->callback_data;
        fe->m_ref_func = ef->lv2_event_ref;
        fe->m_unref_func = ef->lv2_event_unref;
        fe->m_ok = true;
      }
      
    protected:
      
      uint32_t event_ref(LV2_Event* event) {
        return m_ref_func(m_callback_data, event);
      }
    
      uint32_t event_unref(LV2_Event* event) {
        return m_unref_func(m_callback_data, event);
      }
    
      LV2_Event_Callback_Data m_callback_data;
      uint32_t (*m_ref_func)(LV2_Event_Callback_Data, LV2_Event*);
      uint32_t (*m_unref_func)(LV2_Event_Callback_Data, LV2_Event*);
      
    };
    
  };


  template <bool Required = true>
  struct MsgContext {
    
    template <class Derived> struct I : Extension<Required> {
      
      I() { }
      
      static void map_feature_handlers(FeatureHandlerMap& hmap) {
        hmap[LV2_CONTEXT_MESSAGE] = &I<Derived>::handle_feature;
      }
      
      static void handle_feature(void* instance, void* data) { 
        Derived* d = reinterpret_cast<Derived*>(instance);
        I<Derived>* fe = static_cast<I<Derived>*>(d);
        fe->m_ok = true;
      }
      
      static const void* extension_data(const char* uri) { 
        if (!std::strcmp(uri, LV2_CONTEXT_MESSAGE)) {
          static LV2_Blocking_Context desc = { &I<Derived>::_blocking_run,
                                               &I<Derived>::_connect_port };
          return &desc;
        }
        return 0;
      }
      
      bool blocking_run(uint8_t* outputs_written) { return false; }
      
    protected:
      
      static bool _blocking_run(LV2_Handle h, uint8_t* outputs_written) {
        return reinterpret_cast<Derived*>(h)->blocking_run(outputs_written);
      }
      
      static void _connect_port(LV2_Handle h, uint32_t port, void* buffer) {
        reinterpret_cast<Derived*>(h)->connect_port(port, buffer);
      }
      
    };
  };


}


#endif