ladspaplugin.hpp

/****************************************************************************
    
    ladspaplugin.hpp - support file for writing LADSPA plugins in C++
    
    Copyright (C) 2005  Lars Luthman <larsl@users.sourceforge.net>
    
    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; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 01222-1307  USA

****************************************************************************/

#ifndef LADSPAPLUGIN_HPP
#define LADSPAPLUGIN_HPP

#include <unistd.h>

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

#include <ladspa.h>


/* This struct contains data for a single port. You should not have
   to use it directly, use the LADSPAPortList::add_port() functions
   instead. */
struct LADSPAPort {
  LADSPAPort(LADSPA_PortDescriptor descriptor, const std::string& name, 
             const LADSPA_PortRangeHint& hint)
    : m_descriptor(descriptor), m_name(name), m_hint(hint) { }
  LADSPAPort(LADSPA_PortDescriptor descriptor, const std::string& name)
    : m_descriptor(descriptor), m_name(name) {
    memset(&m_hint, 0, sizeof(LADSPA_PortRangeHint));
  }

  LADSPA_PortDescriptor m_descriptor;
  std::string m_name;
  LADSPA_PortRangeHint m_hint;
};


struct LADSPAPortList : public std::vector<LADSPAPort> {
  
  void add_port(LADSPA_PortDescriptor descriptor, const std::string& name,
                const LADSPA_PortRangeHint& hint) {
    push_back(LADSPAPort(descriptor, name, hint));
  }
  
  void add_port(LADSPA_PortDescriptor descriptor, const std::string& name) {
    push_back(LADSPAPort(descriptor, name));
  }
  
  void add_port(LADSPA_PortDescriptor descriptor, const std::string name,
                LADSPA_PortRangeHintDescriptor rh_desc,
                LADSPA_Data lower_bound, LADSPA_Data upper_bound) {
    LADSPA_PortRangeHint prh = { rh_desc, lower_bound, upper_bound };
    push_back(LADSPAPort(descriptor, name, prh));
  }
};


class LADSPAPlugin {
public:
  
  virtual ~LADSPAPlugin() { }
  
  virtual void connect_port(unsigned long port, LADSPA_Data* data_location) {
    m_ports[port] = data_location;
  }
  
  virtual void activate() { }
  
  virtual void run(unsigned long sample_count) { }
  
  virtual void deactivate() { }
  
protected:
  
  /* This needs to be a friend since it resizes the m_ports vector. */
  template <class T> friend
  LADSPA_Handle create_plugin_instance(const LADSPA_Descriptor* descriptor,
                                       unsigned long sample_rate);
  template <class T> friend
  size_t register_ladspa(unsigned long uid, const std::string& label, 
                         LADSPA_Properties properties, const std::string& name,
                         const std::string& maker, const std::string& copyright,
                         const LADSPAPortList& ports);
  


  std::vector<LADSPA_Data*> m_ports;
  
};


/* These functions are C wrappers for the C++ member functions. You should not
   use them directly. */
void connect_port(LADSPA_Handle instance, unsigned long port, 
                  LADSPA_Data* data_location);
void activate(LADSPA_Handle instance);
void run(LADSPA_Handle instance, unsigned long sample_count);
void deactivate(LADSPA_Handle instance);


/* This template function creates an instance of a plugin. It is used as
   the instantiate() callback in the LADSPA descriptor. You should not use
   it directly. */
template <class T>
LADSPA_Handle create_plugin_instance(const LADSPA_Descriptor* descriptor,
                                     unsigned long sample_rate) {
  T* t = new T(sample_rate);
  t->m_ports.resize(descriptor->PortCount, NULL);
  return reinterpret_cast<LADSPA_Descriptor*>(t);
}


/* This template function destroys an instance of a plugin. It is used as
   the cleanup() callback in the LADSPA descriptor. You should not use it
   directly. */
template <class T>
void delete_plugin_instance(LADSPA_Handle instance) {
  delete reinterpret_cast<LADSPAPlugin*>(instance);
}


/* This function returns the list of LADSPA descriptors. It should only be used
   internally. */
std::vector<LADSPA_Descriptor>& get_ladspa_descriptors();


template <class T>
size_t register_ladspa(unsigned long uid, const std::string& label, 
                       LADSPA_Properties properties, const std::string& name,
                       const std::string& maker, const std::string& copyright,
                       const LADSPAPortList& ports) {
  
  LADSPA_Descriptor l_descriptor;
  memset(&l_descriptor, 0, sizeof(LADSPA_Descriptor));
  
  l_descriptor.UniqueID = uid;
  l_descriptor.Label = strdup(label.c_str());
  l_descriptor.Properties = properties;
  l_descriptor.Name = strdup(name.c_str());
  l_descriptor.Maker = strdup(maker.c_str());
  l_descriptor.Copyright = strdup(copyright.c_str());
  
  l_descriptor.PortCount = ports.size();
  LADSPA_PortDescriptor* port_desc = 
    (LADSPA_PortDescriptor*)calloc(ports.size(), sizeof(LADSPA_PortDescriptor));
  char** port_name = (char**)calloc(ports.size(), sizeof(const char*));
  LADSPA_PortRangeHint* port_hint = 
    (LADSPA_PortRangeHint*)calloc(ports.size(), sizeof(LADSPA_PortRangeHint));
  for (unsigned i = 0; i < ports.size(); ++i) {
    port_desc[i] = ports[i].m_descriptor;
    port_name[i] = strdup(ports[i].m_name.c_str());
    port_hint[i] = ports[i].m_hint;
  }
  l_descriptor.PortDescriptors = port_desc;
  l_descriptor.PortNames = port_name;
  l_descriptor.PortRangeHints = port_hint;
  
  l_descriptor.instantiate = &create_plugin_instance<T>;
  l_descriptor.cleanup = &delete_plugin_instance<T>;
  l_descriptor.connect_port = &connect_port;
  l_descriptor.activate = &activate;
  l_descriptor.run = &run;
  l_descriptor.deactivate = &deactivate;
  
  get_ladspa_descriptors().push_back(l_descriptor);
  
  return get_ladspa_descriptors().size() - 1;
}


#endif

---