comparison vamp-sdk/PluginAdapter.cpp @ 22:1eb44d33a371

* Rename simplehost to vamp-simple-host
* Add a temporary test for validity of plugin instances with overlapping
  lifespans

     authorization.
 */
 
 #include "PluginAdapter.h"
 
+#define DEBUG_PLUGIN_ADAPTER 1
+
+
 namespace Vamp {
 
 PluginAdapterBase::PluginAdapterBase() :
     m_populated(false)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase[" << this << "]::PluginAdapterBase" << std::endl;
+#endif
 }
 
 const VampPluginDescriptor *
 PluginAdapterBase::getDescriptor()
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase[" << this << "]::getDescriptor" << std::endl;
+#endif
+
     if (m_populated) return &m_descriptor;
 
     Plugin *plugin = createPlugin(48000);
 
     m_parameters = plugin->getParameterDescriptors();

     return &m_descriptor;
 }
 
 PluginAdapterBase::~PluginAdapterBase()
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase[" << this << "]::~PluginAdapterBase" << std::endl;
+#endif
+
     if (!m_populated) return;
 
     free((void *)m_descriptor.name);
     free((void *)m_descriptor.description);
     free((void *)m_descriptor.maker);

 }
 
 PluginAdapterBase *
 PluginAdapterBase::lookupAdapter(VampPluginHandle handle)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::lookupAdapter(" << handle << ")" << std::endl;
+#endif
+
     if (!m_adapterMap) return 0;
     AdapterMap::const_iterator i = m_adapterMap->find(handle);
     if (i == m_adapterMap->end()) return 0;
     return i->second;
 }
 
 VampPluginHandle
 PluginAdapterBase::vampInstantiate(const VampPluginDescriptor *desc,
                                    float inputSampleRate)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampInstantiate(" << desc << ")" << std::endl;
+#endif
+
     if (!m_adapterMap) {
         m_adapterMap = new AdapterMap();
     }
 
     if (m_adapterMap->find(desc) == m_adapterMap->end()) {

     Plugin *plugin = adapter->createPlugin(inputSampleRate);
     if (plugin) {
         (*m_adapterMap)[plugin] = adapter;
     }
 
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampInstantiate(" << desc << "): returning handle " << plugin << std::endl;
+#endif
+
     return plugin;
 }
 
 void
 PluginAdapterBase::vampCleanup(VampPluginHandle handle)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampCleanup(" << handle << ")" << std::endl;
+#endif
+
     PluginAdapterBase *adapter = lookupAdapter(handle);
     if (!adapter) {
         delete ((Plugin *)handle);
         return;
     }

 PluginAdapterBase::vampInitialise(VampPluginHandle handle,
                                   unsigned int channels,
                                   unsigned int stepSize,
                                   unsigned int blockSize)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampInitialise(" << handle << ", " << channels << ", " << stepSize << ", " << blockSize << ")" << std::endl;
+#endif
+
     bool result = ((Plugin *)handle)->initialise
         (channels, stepSize, blockSize);
     return result ? 1 : 0;
 }
 
 void
 PluginAdapterBase::vampReset(VampPluginHandle handle) 
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampReset(" << handle << ")" << std::endl;
+#endif
+
     ((Plugin *)handle)->reset();
 }
 
 float
 PluginAdapterBase::vampGetParameter(VampPluginHandle handle,
                                     int param) 
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampGetParameter(" << handle << ", " << param << ")" << std::endl;
+#endif
+
     PluginAdapterBase *adapter = lookupAdapter(handle);
     if (!adapter) return 0.0;
     Plugin::ParameterList &list = adapter->m_parameters;
     return ((Plugin *)handle)->getParameter(list[param].name);
 }
 
 void
 PluginAdapterBase::vampSetParameter(VampPluginHandle handle,
                                     int param, float value)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampSetParameter(" << handle << ", " << param << ", " << value << ")" << std::endl;
+#endif
+
     PluginAdapterBase *adapter = lookupAdapter(handle);
     if (!adapter) return;
     Plugin::ParameterList &list = adapter->m_parameters;
     ((Plugin *)handle)->setParameter(list[param].name, value);
 }
 
 unsigned int
 PluginAdapterBase::vampGetCurrentProgram(VampPluginHandle handle)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampGetCurrentProgram(" << handle << ")" << std::endl;
+#endif
+
     PluginAdapterBase *adapter = lookupAdapter(handle);
     if (!adapter) return 0;
     Plugin::ProgramList &list = adapter->m_programs;
     std::string program = ((Plugin *)handle)->getCurrentProgram();
     for (unsigned int i = 0; i < list.size(); ++i) {

 
 void
 PluginAdapterBase::vampSelectProgram(VampPluginHandle handle,
                                      unsigned int program)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampSelectProgram(" << handle << ", " << program << ")" << std::endl;
+#endif
+
     PluginAdapterBase *adapter = lookupAdapter(handle);
     if (!adapter) return;
     Plugin::ProgramList &list = adapter->m_programs;
     ((Plugin *)handle)->selectProgram(list[program]);
 }
 
 unsigned int
 PluginAdapterBase::vampGetPreferredStepSize(VampPluginHandle handle)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampGetPreferredStepSize(" << handle << ")" << std::endl;
+#endif
+
     return ((Plugin *)handle)->getPreferredStepSize();
 }
 
 unsigned int
 PluginAdapterBase::vampGetPreferredBlockSize(VampPluginHandle handle) 
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampGetPreferredBlockSize(" << handle << ")" << std::endl;
+#endif
+
     return ((Plugin *)handle)->getPreferredBlockSize();
 }
 
 unsigned int
 PluginAdapterBase::vampGetMinChannelCount(VampPluginHandle handle)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampGetMinChannelCount(" << handle << ")" << std::endl;
+#endif
+
     return ((Plugin *)handle)->getMinChannelCount();
 }
 
 unsigned int
 PluginAdapterBase::vampGetMaxChannelCount(VampPluginHandle handle)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampGetMaxChannelCount(" << handle << ")" << std::endl;
+#endif
+
     return ((Plugin *)handle)->getMaxChannelCount();
 }
 
 unsigned int
 PluginAdapterBase::vampGetOutputCount(VampPluginHandle handle)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampGetOutputCount(" << handle << ")" << std::endl;
+#endif
+
     PluginAdapterBase *adapter = lookupAdapter(handle);
 
 //    std::cerr << "vampGetOutputCount: handle " << handle << " -> adapter "<< adapter << std::endl;
 
     if (!adapter) return 0;

 
 VampOutputDescriptor *
 PluginAdapterBase::vampGetOutputDescriptor(VampPluginHandle handle,
                                            unsigned int i)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampGetOutputDescriptor(" << handle << ", " << i << ")" << std::endl;
+#endif
+
     PluginAdapterBase *adapter = lookupAdapter(handle);
 
 //    std::cerr << "vampGetOutputDescriptor: handle " << handle << " -> adapter "<< adapter << std::endl;
 
     if (!adapter) return 0;

 }
 
 void
 PluginAdapterBase::vampReleaseOutputDescriptor(VampOutputDescriptor *desc)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampReleaseOutputDescriptor(" << desc << ")" << std::endl;
+#endif
+
     if (desc->name) free((void *)desc->name);
     if (desc->description) free((void *)desc->description);
     if (desc->unit) free((void *)desc->unit);
     for (unsigned int i = 0; i < desc->binCount; ++i) {
         free((void *)desc->binNames[i]);

 PluginAdapterBase::vampProcess(VampPluginHandle handle,
                                float **inputBuffers,
                                int sec,
                                int nsec)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampProcess(" << handle << ", " << sec << ", " << nsec << ")" << std::endl;
+#endif
+
     PluginAdapterBase *adapter = lookupAdapter(handle);
     if (!adapter) return 0;
     return adapter->process((Plugin *)handle,
                             inputBuffers, sec, nsec);
 }
 
 VampFeatureList *
 PluginAdapterBase::vampGetRemainingFeatures(VampPluginHandle handle)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampGetRemainingFeatures(" << handle << ")" << std::endl;
+#endif
+
     PluginAdapterBase *adapter = lookupAdapter(handle);
     if (!adapter) return 0;
     return adapter->getRemainingFeatures((Plugin *)handle);
 }
 
 void
 PluginAdapterBase::vampReleaseFeatureSet(VampFeatureList *fs)
 {
+#ifdef DEBUG_PLUGIN_ADAPTER
+    std::cerr << "PluginAdapterBase::vampReleaseFeatureSet" << std::endl;
+#endif
 }
 
 void 
 PluginAdapterBase::cleanup(Plugin *plugin)
 {