comparison src/vamp-sdk/PluginAdapter.cpp @ 532:569fc23fa37a

Merge from branch c++11-mutex

 #include <vamp-sdk/PluginAdapter.h>
 
 #include <cstring>
 #include <cstdlib>
 
-#if ( VAMP_SDK_MAJOR_VERSION != 2 || VAMP_SDK_MINOR_VERSION != 8 )
+#include <mutex>
+
+#if ( VAMP_SDK_MAJOR_VERSION != 2 || VAMP_SDK_MINOR_VERSION != 9 )
 #error Unexpected version of Vamp SDK header included
 #endif
 
+using std::map;
+using std::vector;
+using std::string;
+using std::cerr;
+using std::endl;
+using std::mutex;
+using std::lock_guard;
 
 //#define DEBUG_PLUGIN_ADAPTER 1
 
 _VAMP_SDK_PLUGSPACE_BEGIN(PluginAdapter.cpp)
 

     void checkOutputMap(Plugin *plugin);
     void markOutputsChanged(Plugin *plugin);
 
     void cleanup(Plugin *plugin);
     unsigned int getOutputCount(Plugin *plugin);
-    VampOutputDescriptor *getOutputDescriptor(Plugin *plugin,
-                                             unsigned int i);
+    VampOutputDescriptor *getOutputDescriptor(Plugin *plugin, unsigned int i);
     VampFeatureList *process(Plugin *plugin,
                              const float *const *inputBuffers,
                              int sec, int nsec);
     VampFeatureList *getRemainingFeatures(Plugin *plugin);
     VampFeatureList *convertFeatures(Plugin *plugin,
                                      const Plugin::FeatureSet &features);
     
     // maps both plugins and descriptors to adapters
-    typedef std::map<const void *, Impl *> AdapterMap;
+    typedef map<const void *, Impl *> AdapterMap;
+
     static AdapterMap *m_adapterMap;
+
+    static mutex &adapterMapMutex() {
+        // If this mutex was a global static, then it might be
+        // destroyed before the last adapter, and we would end up
+        // trying to lock an invalid mutex when removing an adapter
+        // from the adapter map. To ensure it outlasts the adapters,
+        // we need to ensure it is constructed before the construction
+        // of any of them is complete, since destruction order is
+        // reverse of construction. So we have to make sure this is
+        // called from the PluginAdapterBase::Impl constructor below.
+        static mutex m;
+        return m;
+    }
+        
     static Impl *lookupAdapter(VampPluginHandle);
 
+    mutex m_mutex; // guards all of the below
+    
     bool m_populated;
     VampPluginDescriptor m_descriptor;
     Plugin::ParameterList m_parameters;
     Plugin::ProgramList m_programs;
     
-    typedef std::map<Plugin *, Plugin::OutputList *> OutputMap;
+    typedef map<Plugin *, Plugin::OutputList *> OutputMap;
     OutputMap m_pluginOutputs;
 
-    std::map<Plugin *, VampFeatureList *> m_fs;
-    std::map<Plugin *, std::vector<size_t> > m_fsizes;
-    std::map<Plugin *, std::vector<std::vector<size_t> > > m_fvsizes;
+    map<Plugin *, VampFeatureList *> m_fs;
+    map<Plugin *, vector<size_t> > m_fsizes;
+    map<Plugin *, vector<vector<size_t> > > m_fvsizes;
     void resizeFS(Plugin *plugin, int n);
     void resizeFL(Plugin *plugin, int n, size_t sz);
     void resizeFV(Plugin *plugin, int n, int j, size_t sz);
 };
 

 PluginAdapterBase::Impl::Impl(PluginAdapterBase *base) :
     m_base(base),
     m_populated(false)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl[" << this << "]::Impl" << std::endl;
-#endif
+    cerr << "PluginAdapterBase::Impl[" << this << "]::Impl" << endl;
+#endif
+
+    (void)adapterMapMutex(); // see comment in adapterMapMutex function above
 }
 
 const VampPluginDescriptor *
 PluginAdapterBase::Impl::getDescriptor()
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl[" << this << "]::getDescriptor" << std::endl;
-#endif
-
+    cerr << "PluginAdapterBase::Impl[" << this << "]::getDescriptor" << endl;
+#endif
+
+    lock_guard<mutex> guard(m_mutex);
+    
     if (m_populated) return &m_descriptor;
     
     Plugin *plugin = m_base->createPlugin(48000);
   
     if (!plugin) {
-        std::cerr << "PluginAdapterBase::Impl::getDescriptor: Failed to create plugin" << std::endl;
+        cerr << "PluginAdapterBase::Impl::getDescriptor: Failed to create plugin" << endl;
         return 0;
     }
 
     if (plugin->getVampApiVersion() != VAMP_API_VERSION) {
-        std::cerr << "Vamp::PluginAdapterBase::Impl::getDescriptor: ERROR: "
-                  << "API version " << plugin->getVampApiVersion()
-                  << " for\nplugin \"" << plugin->getIdentifier() << "\" "
-                  << "differs from version "
-                  << VAMP_API_VERSION << " for adapter.\n"
-                  << "This plugin is probably linked against a different version of the Vamp SDK\n"
-                  << "from the version it was compiled with.  It will need to be re-linked correctly\n"
-                  << "before it can be used." << std::endl;
+        cerr << "Vamp::PluginAdapterBase::Impl::getDescriptor: ERROR: "
+             << "API version " << plugin->getVampApiVersion()
+             << " for\nplugin \"" << plugin->getIdentifier() << "\" "
+             << "differs from version "
+             << VAMP_API_VERSION << " for adapter.\n"
+             << "This plugin is probably linked against a different version of the Vamp SDK\n"
+             << "from the version it was compiled with.  It will need to be re-linked correctly\n"
+             << "before it can be used." << endl;
         delete plugin;
         return 0;
     }
 
     m_parameters = plugin->getParameterDescriptors();

     m_descriptor.getOutputDescriptor = vampGetOutputDescriptor;
     m_descriptor.releaseOutputDescriptor = vampReleaseOutputDescriptor;
     m_descriptor.process = vampProcess;
     m_descriptor.getRemainingFeatures = vampGetRemainingFeatures;
     m_descriptor.releaseFeatureSet = vampReleaseFeatureSet;
+
+    lock_guard<mutex> adapterMapGuard(adapterMapMutex());
     
     if (!m_adapterMap) {
         m_adapterMap = new AdapterMap;
     }
     (*m_adapterMap)[&m_descriptor] = this;

 }
 
 PluginAdapterBase::Impl::~Impl()
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl[" << this << "]::~Impl" << std::endl;
-#endif
+    cerr << "PluginAdapterBase::Impl[" << this << "]::~Impl" << endl;
+#endif
+
+    lock_guard<mutex> guard(m_mutex);
 
     if (!m_populated) return;
 
     free((void *)m_descriptor.identifier);
     free((void *)m_descriptor.name);

     for (unsigned int i = 0; i < m_descriptor.programCount; ++i) {
         free((void *)m_descriptor.programs[i]);
     }
     free((void *)m_descriptor.programs);
 
+    lock_guard<mutex> adapterMapGuard(adapterMapMutex());
+    
     if (m_adapterMap) {
         
         m_adapterMap->erase(&m_descriptor);
-
+        
         if (m_adapterMap->empty()) {
             delete m_adapterMap;
             m_adapterMap = 0;
         }
     }

 
 PluginAdapterBase::Impl *
 PluginAdapterBase::Impl::lookupAdapter(VampPluginHandle handle)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::lookupAdapter(" << handle << ")" << std::endl;
-#endif
-
+    cerr << "PluginAdapterBase::Impl::lookupAdapter(" << handle << ")" << endl;
+#endif
+
+    lock_guard<mutex> adapterMapGuard(adapterMapMutex());
+    
     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::Impl::vampInstantiate(const VampPluginDescriptor *desc,
                                          float inputSampleRate)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampInstantiate(" << desc << ")" << std::endl;
-#endif
-
+    cerr << "PluginAdapterBase::Impl::vampInstantiate(" << desc << ")" << endl;
+#endif
+
+    lock_guard<mutex> adapterMapGuard(adapterMapMutex());
+    
     if (!m_adapterMap) {
         m_adapterMap = new AdapterMap();
     }
 
     if (m_adapterMap->find(desc) == m_adapterMap->end()) {
-        std::cerr << "WARNING: PluginAdapterBase::Impl::vampInstantiate: Descriptor " << desc << " not in adapter map" << std::endl;
+        cerr << "WARNING: PluginAdapterBase::Impl::vampInstantiate: Descriptor " << desc << " not in adapter map" << endl;
         return 0;
     }
 
     Impl *adapter = (*m_adapterMap)[desc];
     if (desc != &adapter->m_descriptor) return 0;

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

                                         unsigned int channels,
                                         unsigned int stepSize,
                                         unsigned int blockSize)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampInitialise(" << handle << ", " << channels << ", " << stepSize << ", " << blockSize << ")" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampInitialise(" << handle << ", " << channels << ", " << stepSize << ", " << blockSize << ")" << endl;
 #endif
 
     Impl *adapter = lookupAdapter(handle);
     if (!adapter) return 0;
     bool result = ((Plugin *)handle)->initialise(channels, stepSize, blockSize);

 
 void
 PluginAdapterBase::Impl::vampReset(VampPluginHandle handle) 
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampReset(" << handle << ")" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampReset(" << handle << ")" << endl;
 #endif
 
     ((Plugin *)handle)->reset();
 }
 
 float
 PluginAdapterBase::Impl::vampGetParameter(VampPluginHandle handle,
                                     int param) 
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampGetParameter(" << handle << ", " << param << ")" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampGetParameter(" << handle << ", " << param << ")" << endl;
 #endif
 
     Impl *adapter = lookupAdapter(handle);
     if (!adapter) return 0.0;
     Plugin::ParameterList &list = adapter->m_parameters;

 void
 PluginAdapterBase::Impl::vampSetParameter(VampPluginHandle handle,
                                     int param, float value)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampSetParameter(" << handle << ", " << param << ", " << value << ")" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampSetParameter(" << handle << ", " << param << ", " << value << ")" << endl;
 #endif
 
     Impl *adapter = lookupAdapter(handle);
     if (!adapter) return;
     Plugin::ParameterList &list = adapter->m_parameters;

 
 unsigned int
 PluginAdapterBase::Impl::vampGetCurrentProgram(VampPluginHandle handle)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampGetCurrentProgram(" << handle << ")" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampGetCurrentProgram(" << handle << ")" << endl;
 #endif
 
     Impl *adapter = lookupAdapter(handle);
     if (!adapter) return 0;
     Plugin::ProgramList &list = adapter->m_programs;
-    std::string program = ((Plugin *)handle)->getCurrentProgram();
+    string program = ((Plugin *)handle)->getCurrentProgram();
     for (unsigned int i = 0; i < list.size(); ++i) {
         if (list[i] == program) return i;
     }
     return 0;
 }

 void
 PluginAdapterBase::Impl::vampSelectProgram(VampPluginHandle handle,
                                            unsigned int program)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampSelectProgram(" << handle << ", " << program << ")" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampSelectProgram(" << handle << ", " << program << ")" << endl;
 #endif
 
     Impl *adapter = lookupAdapter(handle);
     if (!adapter) return;
 

 
 unsigned int
 PluginAdapterBase::Impl::vampGetPreferredStepSize(VampPluginHandle handle)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampGetPreferredStepSize(" << handle << ")" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampGetPreferredStepSize(" << handle << ")" << endl;
 #endif
 
     return ((Plugin *)handle)->getPreferredStepSize();
 }
 
 unsigned int
 PluginAdapterBase::Impl::vampGetPreferredBlockSize(VampPluginHandle handle) 
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampGetPreferredBlockSize(" << handle << ")" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampGetPreferredBlockSize(" << handle << ")" << endl;
 #endif
 
     return ((Plugin *)handle)->getPreferredBlockSize();
 }
 
 unsigned int
 PluginAdapterBase::Impl::vampGetMinChannelCount(VampPluginHandle handle)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampGetMinChannelCount(" << handle << ")" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampGetMinChannelCount(" << handle << ")" << endl;
 #endif
 
     return ((Plugin *)handle)->getMinChannelCount();
 }
 
 unsigned int
 PluginAdapterBase::Impl::vampGetMaxChannelCount(VampPluginHandle handle)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampGetMaxChannelCount(" << handle << ")" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampGetMaxChannelCount(" << handle << ")" << endl;
 #endif
 
     return ((Plugin *)handle)->getMaxChannelCount();
 }
 
 unsigned int
 PluginAdapterBase::Impl::vampGetOutputCount(VampPluginHandle handle)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampGetOutputCount(" << handle << ")" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampGetOutputCount(" << handle << ")" << endl;
 #endif
 
     Impl *adapter = lookupAdapter(handle);
 
-//    std::cerr << "vampGetOutputCount: handle " << handle << " -> adapter "<< adapter << std::endl;
+//    cerr << "vampGetOutputCount: handle " << handle << " -> adapter "<< adapter << endl;
 
     if (!adapter) return 0;
     return adapter->getOutputCount((Plugin *)handle);
 }
 
 VampOutputDescriptor *
 PluginAdapterBase::Impl::vampGetOutputDescriptor(VampPluginHandle handle,
                                                  unsigned int i)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampGetOutputDescriptor(" << handle << ", " << i << ")" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampGetOutputDescriptor(" << handle << ", " << i << ")" << endl;
 #endif
 
     Impl *adapter = lookupAdapter(handle);
 
-//    std::cerr << "vampGetOutputDescriptor: handle " << handle << " -> adapter "<< adapter << std::endl;
+//    cerr << "vampGetOutputDescriptor: handle " << handle << " -> adapter "<< adapter << endl;
 
     if (!adapter) return 0;
     return adapter->getOutputDescriptor((Plugin *)handle, i);
 }
 
 void
 PluginAdapterBase::Impl::vampReleaseOutputDescriptor(VampOutputDescriptor *desc)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampReleaseOutputDescriptor(" << desc << ")" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampReleaseOutputDescriptor(" << desc << ")" << endl;
 #endif
 
     if (desc->identifier) free((void *)desc->identifier);
     if (desc->name) free((void *)desc->name);
     if (desc->description) free((void *)desc->description);

                                      const float *const *inputBuffers,
                                      int sec,
                                      int nsec)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampProcess(" << handle << ", " << sec << ", " << nsec << ")" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampProcess(" << handle << ", " << sec << ", " << nsec << ")" << endl;
 #endif
 
     Impl *adapter = lookupAdapter(handle);
     if (!adapter) return 0;
     return adapter->process((Plugin *)handle, inputBuffers, sec, nsec);

 
 VampFeatureList *
 PluginAdapterBase::Impl::vampGetRemainingFeatures(VampPluginHandle handle)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampGetRemainingFeatures(" << handle << ")" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampGetRemainingFeatures(" << handle << ")" << endl;
 #endif
 
     Impl *adapter = lookupAdapter(handle);
     if (!adapter) return 0;
     return adapter->getRemainingFeatures((Plugin *)handle);

 
 void
 PluginAdapterBase::Impl::vampReleaseFeatureSet(VampFeatureList *)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::vampReleaseFeatureSet" << std::endl;
+    cerr << "PluginAdapterBase::Impl::vampReleaseFeatureSet" << endl;
 #endif
 }
 
 void 
 PluginAdapterBase::Impl::cleanup(Plugin *plugin)
 {
+    // at this point no mutex is held
+    
+    lock_guard<mutex> adapterMapGuard(adapterMapMutex());
+    lock_guard<mutex> guard(m_mutex);
+    
     if (m_fs.find(plugin) != m_fs.end()) {
         size_t outputCount = 0;
         if (m_pluginOutputs[plugin]) {
             outputCount = m_pluginOutputs[plugin]->size();
         }
 #ifdef DEBUG_PLUGIN_ADAPTER
-        std::cerr << "PluginAdapterBase::Impl::cleanup: " << outputCount << " output(s)" << std::endl;
+        cerr << "PluginAdapterBase::Impl::cleanup: " << outputCount << " output(s)" << endl;
 #endif
         VampFeatureList *list = m_fs[plugin];
         for (unsigned int i = 0; i < outputCount; ++i) {
             for (unsigned int j = 0; j < m_fsizes[plugin][i]; ++j) {
                 if (list[i].features[j].v1.label) {

 }
 
 void 
 PluginAdapterBase::Impl::checkOutputMap(Plugin *plugin)
 {
+    // must be called with m_mutex held
+    
     OutputMap::iterator i = m_pluginOutputs.find(plugin);
 
     if (i == m_pluginOutputs.end() || !i->second) {
 
         m_pluginOutputs[plugin] = new Plugin::OutputList
             (plugin->getOutputDescriptors());
 
-//        std::cerr << "PluginAdapterBase::Impl::checkOutputMap: Have " << m_pluginOutputs[plugin]->size() << " outputs for plugin " << plugin->getIdentifier() << std::endl;
+//        cerr << "PluginAdapterBase::Impl::checkOutputMap: Have " << m_pluginOutputs[plugin]->size() << " outputs for plugin " << plugin->getIdentifier() << endl;
     }
 }
 
 void
 PluginAdapterBase::Impl::markOutputsChanged(Plugin *plugin)
 {
+    lock_guard<mutex> guard(m_mutex);
+
     OutputMap::iterator i = m_pluginOutputs.find(plugin);
 
-//    std::cerr << "PluginAdapterBase::Impl::markOutputsChanged" << std::endl;
+//    cerr << "PluginAdapterBase::Impl::markOutputsChanged" << endl;
 
     if (i != m_pluginOutputs.end()) {
 
         Plugin::OutputList *list = i->second;
         m_pluginOutputs.erase(i);

 }
 
 unsigned int 
 PluginAdapterBase::Impl::getOutputCount(Plugin *plugin)
 {
+    lock_guard<mutex> guard(m_mutex);
+
     checkOutputMap(plugin);
 
     return m_pluginOutputs[plugin]->size();
 }
 
 VampOutputDescriptor *
 PluginAdapterBase::Impl::getOutputDescriptor(Plugin *plugin,
                                              unsigned int i)
 {
+    lock_guard<mutex> guard(m_mutex);
+
     checkOutputMap(plugin);
 
     Plugin::OutputDescriptor &od =
         (*m_pluginOutputs[plugin])[i];
 

 VampFeatureList *
 PluginAdapterBase::Impl::process(Plugin *plugin,
                                  const float *const *inputBuffers,
                                  int sec, int nsec)
 {
-//    std::cerr << "PluginAdapterBase::Impl::process" << std::endl;
+//    cerr << "PluginAdapterBase::Impl::process" << endl;
+
     RealTime rt(sec, nsec);
-    checkOutputMap(plugin);
+
+    // We don't want to hold the mutex during the actual process call,
+    // only while looking up the associated metadata
+    {    
+        lock_guard<mutex> guard(m_mutex);
+        checkOutputMap(plugin);
+    }
+
     return convertFeatures(plugin, plugin->process(inputBuffers, rt));
 }
     
 VampFeatureList *
 PluginAdapterBase::Impl::getRemainingFeatures(Plugin *plugin)
 {
-//    std::cerr << "PluginAdapterBase::Impl::getRemainingFeatures" << std::endl;
-    checkOutputMap(plugin);
+//    cerr << "PluginAdapterBase::Impl::getRemainingFeatures" << endl;
+
+    // We don't want to hold the mutex during the actual call, only
+    // while looking up the associated metadata
+    {    
+        lock_guard<mutex> guard(m_mutex);
+        checkOutputMap(plugin);
+    }
+
     return convertFeatures(plugin, plugin->getRemainingFeatures());
 }
 
 VampFeatureList *
 PluginAdapterBase::Impl::convertFeatures(Plugin *plugin,
                                          const Plugin::FeatureSet &features)
 {
+    lock_guard<mutex> guard(m_mutex);
+
     int lastN = -1;
 
     int outputCount = 0;
     if (m_pluginOutputs[plugin]) outputCount = m_pluginOutputs[plugin]->size();
     
     resizeFS(plugin, outputCount);
     VampFeatureList *fs = m_fs[plugin];
 
-//    std::cerr << "PluginAdapter(v2)::convertFeatures: NOTE: sizeof(Feature) == " << sizeof(Plugin::Feature) << ", sizeof(VampFeature) == " << sizeof(VampFeature) << ", sizeof(VampFeatureList) == " << sizeof(VampFeatureList) << std::endl;
+//    cerr << "PluginAdapter(v2)::convertFeatures: NOTE: sizeof(Feature) == " << sizeof(Plugin::Feature) << ", sizeof(VampFeature) == " << sizeof(VampFeature) << ", sizeof(VampFeatureList) == " << sizeof(VampFeatureList) << endl;
 
     for (Plugin::FeatureSet::const_iterator fi = features.begin();
          fi != features.end(); ++fi) {
 
         int n = fi->first;
         
-//        std::cerr << "PluginAdapterBase::Impl::convertFeatures: n = " << n << std::endl;
+//        cerr << "PluginAdapterBase::Impl::convertFeatures: n = " << n << endl;
 
         if (n >= int(outputCount)) {
-            std::cerr << "WARNING: PluginAdapterBase::Impl::convertFeatures: Too many outputs from plugin (" << n+1 << ", only should be " << outputCount << ")" << std::endl;
+            cerr << "WARNING: PluginAdapterBase::Impl::convertFeatures: Too many outputs from plugin (" << n+1 << ", only should be " << outputCount << ")" << endl;
             continue;
         }
 
         if (n > lastN + 1) {
             for (int i = lastN + 1; i < n; ++i) {

         if (sz > m_fsizes[plugin][n]) resizeFL(plugin, n, sz);
         fs[n].featureCount = sz;
         
         for (size_t j = 0; j < sz; ++j) {
 
-//            std::cerr << "PluginAdapterBase::Impl::convertFeatures: j = " << j << std::endl;
+//            cerr << "PluginAdapterBase::Impl::convertFeatures: j = " << j << endl;
 
             VampFeature *feature = &fs[n].features[j].v1;
 
             feature->hasTimestamp = fl[j].hasTimestamp;
             feature->sec = fl[j].timestamp.sec;

             if (feature->valueCount > m_fvsizes[plugin][n][j]) {
                 resizeFV(plugin, n, j, feature->valueCount);
             }
 
             for (unsigned int k = 0; k < feature->valueCount; ++k) {
-//                std::cerr << "PluginAdapterBase::Impl::convertFeatures: k = " << k << std::endl;
+//                cerr << "PluginAdapterBase::Impl::convertFeatures: k = " << k << endl;
                 feature->values[k] = fl[j].values[k];
             }
         }
 
         lastN = n;

         for (int i = lastN + 1; i < int(outputCount); ++i) {
             fs[i].featureCount = 0;
         }
     }
 
-//    std::cerr << "PluginAdapter(v2)::convertFeatures: NOTE: have " << outputCount << " outputs" << std::endl;
+//    cerr << "PluginAdapter(v2)::convertFeatures: NOTE: have " << outputCount << " outputs" << endl;
 //    for (int i = 0; i < outputCount; ++i) {
-//        std::cerr << "PluginAdapter(v2)::convertFeatures: NOTE: output " << i << " has " << fs[i].featureCount << " features" << std::endl;
+//        cerr << "PluginAdapter(v2)::convertFeatures: NOTE: output " << i << " has " << fs[i].featureCount << " features" << endl;
 //    }
 
 
     return fs;
 }
 
 void
 PluginAdapterBase::Impl::resizeFS(Plugin *plugin, int n)
 {
-#ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::resizeFS(" << plugin << ", " << n << ")" << std::endl;
+    // called with m_mutex held
+    
+#ifdef DEBUG_PLUGIN_ADAPTER
+    cerr << "PluginAdapterBase::Impl::resizeFS(" << plugin << ", " << n << ")" << endl;
 #endif
 
     int i = m_fsizes[plugin].size();
     if (i >= n) return;
 
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "resizing from " << i << std::endl;
+    cerr << "resizing from " << i << endl;
 #endif
 
     m_fs[plugin] = (VampFeatureList *)realloc
         (m_fs[plugin], n * sizeof(VampFeatureList));
 
     while (i < n) {
         m_fs[plugin][i].featureCount = 0;
         m_fs[plugin][i].features = 0;
         m_fsizes[plugin].push_back(0);
-        m_fvsizes[plugin].push_back(std::vector<size_t>());
+        m_fvsizes[plugin].push_back(vector<size_t>());
         i++;
     }
 }
 
 void
 PluginAdapterBase::Impl::resizeFL(Plugin *plugin, int n, size_t sz)
 {
-#ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::resizeFL(" << plugin << ", " << n << ", "
-              << sz << ")" << std::endl;
+    // called with m_mutex held
+    
+#ifdef DEBUG_PLUGIN_ADAPTER
+    cerr << "PluginAdapterBase::Impl::resizeFL(" << plugin << ", " << n << ", "
+              << sz << ")" << endl;
 #endif
     
     size_t i = m_fsizes[plugin][n];
     if (i >= sz) return;
 
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "resizing from " << i << std::endl;
+    cerr << "resizing from " << i << endl;
 #endif
 
     m_fs[plugin][n].features = (VampFeatureUnion *)realloc
         (m_fs[plugin][n].features, 2 * sz * sizeof(VampFeatureUnion));
 

 }
 
 void
 PluginAdapterBase::Impl::resizeFV(Plugin *plugin, int n, int j, size_t sz)
 {
-#ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "PluginAdapterBase::Impl::resizeFV(" << plugin << ", " << n << ", "
-              << j << ", " << sz << ")" << std::endl;
+    // called with m_mutex held
+    
+#ifdef DEBUG_PLUGIN_ADAPTER
+    cerr << "PluginAdapterBase::Impl::resizeFV(" << plugin << ", " << n << ", "
+              << j << ", " << sz << ")" << endl;
 #endif
     
     size_t i = m_fvsizes[plugin][n][j];
     if (i >= sz) return;
 
 #ifdef DEBUG_PLUGIN_ADAPTER
-    std::cerr << "resizing from " << i << std::endl;
+    cerr << "resizing from " << i << endl;
 #endif
     
     m_fs[plugin][n].features[j].v1.values = (float *)realloc
         (m_fs[plugin][n].features[j].v1.values, sz * sizeof(float));