dssiplugin.hpp

Go to the documentation of this file.

/****************************************************************************
    
    dssiplugin.hpp - a class and functions that should make it easier to
                     write DSSI 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 DSSIPLUGIN_HPP
#define DSSIPLUGIN_HPP

#include <unistd.h>

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

#include <dssi.h>


extern "C" {
  /*This is the one function that needs to be in all DSSI plugin libraries.
    It is called by the host and returns descriptors for all plugins that
    the library contains. Only for use by the host, you should not touch this
    in your plugin. */
  /* Yes, this is intentionally not documented with Doxygen comments. */
  const DSSI_Descriptor* dssi_descriptor(unsigned long index);
}


/* A helper class that stores info about a DSSI port. You should not need
   to use this class, it's only for internal use. */
/* Yes, this is intentionally not documented with Doxygen comments. */
struct DSSIPort {
  DSSIPort(LADSPA_PortDescriptor descriptor, const std::string& name, 
           const LADSPA_PortRangeHint& hint)
    : m_descriptor(descriptor), m_name(name), m_hint(hint) { }
  DSSIPort(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;
};


enum DSSIFeatureMask {
  DSSI_NO_FEATURES = 0,
  DSSI_RECEIVES_MIDI = 1 << 0,
  DSSI_HAS_PROGRAMS = 1 << 1,
  DSSI_USES_SHM = 1 << 2
};


inline DSSIFeatureMask operator|(const DSSIFeatureMask& m1, 
                                 const DSSIFeatureMask& m2) {
  return DSSIFeatureMask(static_cast<unsigned>(m1) | static_cast<unsigned>(m2));
}


struct DSSIPortList : public std::vector<DSSIPort> {
  
  int add_port(LADSPA_PortDescriptor descriptor, const std::string& name,
                const LADSPA_PortRangeHint& hint) {
    push_back(DSSIPort(descriptor, name, hint));
    return size() - 1;
  }
  
  int add_port(LADSPA_PortDescriptor descriptor, const std::string& name) {
    push_back(DSSIPort(descriptor, name));
    return size() - 1;
  }
  
  int 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(DSSIPort(descriptor, name, prh));
    return size() - 1;
  }

};



template <class T>
size_t register_dssi(const std::string& label, LADSPA_Properties properties, 
                     const std::string& name, const std::string& maker, 
                     const std::string& copyright, const DSSIPortList& ports,
                     DSSIFeatureMask features = DSSI_RECEIVES_MIDI | 
                     DSSI_HAS_PROGRAMS | DSSI_USES_SHM);



class DSSIPlugin {
public:
  
  // @{
  
  virtual ~DSSIPlugin();
  
  virtual void activate() { }
  
  virtual void deactivate() { }

  // @}

  
  // @{
  
  virtual char* configure(const char* key, const char* value) { return NULL; }
  
  virtual int get_midi_controller_for_port(unsigned long port) { 
    return DSSI_NONE;
  }
  
  virtual const DSSI_Program_Descriptor* get_program(unsigned long index) {
    return NULL;
  }
  
  virtual bool shm_attached(void* shm, size_t size) { 
    return false; 
  }
  
  virtual void shm_detach_request(void* shm) { shm_detach(shm); }
  
  // @}
  

  // @{
  
  virtual void run(unsigned long sample_count) {
    run_synth(sample_count, NULL, 0);
  }

  virtual void run_synth(unsigned long sample_count, snd_seq_event_t* events,
                         unsigned long event_count) { }
  
  virtual void select_program(unsigned long bank, unsigned long program) { }
  
  virtual void connect_port(unsigned long port, LADSPA_Data* data_location) {
    m_ports[port] = data_location;
  }
  
  
  
  friend const DSSI_Descriptor* dssi_descriptor(unsigned long index);
  template <class T> friend 
  size_t register_dssi(const std::string& label, LADSPA_Properties properties, 
                       const std::string& name, const std::string& maker, 
                       const std::string& copyright, const DSSIPortList& ports,
                       DSSIFeatureMask features);

  
protected:

  void shm_detach(void* shm);
  
  std::vector<LADSPA_Data*> m_ports;
  
  
private:

  /* This function returns the global vector of DSSI_Descriptors that is added 
     to by register_dssi(). It is used by the dssi_descriptor() function. */
  static std::vector<DSSI_Descriptor>& get_dssi_descriptors();
  
  /* Static callbacks */
  static void _activate(LADSPA_Handle instance);
  static void _deactivate(LADSPA_Handle instance);
  static void _cleanup(LADSPA_Handle instance);

  static char* _configure(LADSPA_Handle instance, 
                          const char* key, const char* value);
  static char* _configure_with_shm(LADSPA_Handle instance, 
                                   const char* key, const char* value);
  static int _get_midi_controller_for_port(LADSPA_Handle instance, 
                                           unsigned long port);
  static const DSSI_Program_Descriptor* _get_program(LADSPA_Handle instance,
                                                     unsigned long index);
  
  static void _run(LADSPA_Handle instance, unsigned long sample_count);
  static void _run_synth(LADSPA_Handle instance, unsigned long sample_count, 
                         snd_seq_event_t* events, unsigned long event_count);
  static void _select_program(LADSPA_Handle instance, 
                              unsigned long bank, unsigned long program);
  static void _connect_port(LADSPA_Handle instance, unsigned long port, 
                            LADSPA_Data* data_location);
  
  /*This template function is instantiated for each plugin class and used 
    as the instantiation function. */
  template <class T>
  static 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_Handle>(t);
  }

  std::map<std::string, void*> m_segments;
  
};



template <class T>
size_t register_dssi(const std::string& label, LADSPA_Properties properties, 
                     const std::string& name, const std::string& maker, 
                     const std::string& copyright, const DSSIPortList& ports,
                     DSSIFeatureMask features) {
  
  DSSI_Descriptor descriptor;
  memset(&descriptor, 0, sizeof(DSSI_Descriptor));
  descriptor.DSSI_API_Version = 1;
      
  LADSPA_Descriptor* l_descriptor = 
    (LADSPA_Descriptor*)calloc(1, sizeof(LADSPA_Descriptor));
  descriptor.LADSPA_Plugin = l_descriptor;
  
  l_descriptor->UniqueID = 666;
  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 = &DSSIPlugin::create_plugin_instance<T>;
  l_descriptor->cleanup = &DSSIPlugin::_cleanup;
  l_descriptor->connect_port = &DSSIPlugin::_connect_port;
  l_descriptor->activate = &DSSIPlugin::_activate;
  l_descriptor->run = &DSSIPlugin::_run;
  l_descriptor->deactivate = &DSSIPlugin::_deactivate;
  
  if (features & DSSI_USES_SHM)
    descriptor.configure = &DSSIPlugin::_configure_with_shm;
  else
    descriptor.configure = &DSSIPlugin::_configure;
  
  if (features & DSSI_RECEIVES_MIDI) {
    descriptor.run_synth = &DSSIPlugin::_run_synth;
    descriptor.get_midi_controller_for_port =
      &DSSIPlugin::_get_midi_controller_for_port;
  }
  else {
    descriptor.run_synth = 0;
    descriptor.get_midi_controller_for_port = 0;
  }
  
  if (features & DSSI_HAS_PROGRAMS) {
    descriptor.get_program = &DSSIPlugin::_get_program;
    descriptor.select_program = &DSSIPlugin::_select_program;
  }
  else {
    descriptor.get_program = 0;
    descriptor.select_program = 0;
  }
  
  DSSIPlugin::get_dssi_descriptors().push_back(descriptor);
  
  return DSSIPlugin::get_dssi_descriptors().size() - 1;
}



#endif

---