comparison src/vamp-sdk/PluginAdapter.cpp @ 268:6579e441f2fe

* Ensure that output descriptors are re-queried after a call to
  initialise, setParameter or selectProgram (following "What can
  depend on a parameter?" section of programmers guide)

 
     static VampFeatureList *vampGetRemainingFeatures(VampPluginHandle handle);
 
     static void vampReleaseFeatureSet(VampFeatureList *fs);
 
+    void checkOutputMap(Plugin *plugin);
+    void markOutputsChanged(Plugin *plugin);
+
     void cleanup(Plugin *plugin);
-    void checkOutputMap(Plugin *plugin);
     unsigned int getOutputCount(Plugin *plugin);
     VampOutputDescriptor *getOutputDescriptor(Plugin *plugin,
                                              unsigned int i);
     VampFeatureList *process(Plugin *plugin,
                              const float *const *inputBuffers,

     return i->second;
 }
 
 VampPluginHandle
 PluginAdapterBase::Impl::vampInstantiate(const VampPluginDescriptor *desc,
-                                   float inputSampleRate)
+                                         float inputSampleRate)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
     std::cerr << "PluginAdapterBase::Impl::vampInstantiate(" << desc << ")" << std::endl;
 #endif
 

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

 
     Impl *adapter = lookupAdapter(handle);
     if (!adapter) return;
     Plugin::ParameterList &list = adapter->m_parameters;
     ((Plugin *)handle)->setParameter(list[param].identifier, value);
+    adapter->markOutputsChanged((Plugin *)handle);
 }
 
 unsigned int
 PluginAdapterBase::Impl::vampGetCurrentProgram(VampPluginHandle handle)
 {

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

     return adapter->getOutputCount((Plugin *)handle);
 }
 
 VampOutputDescriptor *
 PluginAdapterBase::Impl::vampGetOutputDescriptor(VampPluginHandle handle,
-                                           unsigned int i)
+                                                 unsigned int i)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
     std::cerr << "PluginAdapterBase::Impl::vampGetOutputDescriptor(" << handle << ", " << i << ")" << std::endl;
 #endif
 

     std::cerr << "PluginAdapterBase::Impl::vampProcess(" << handle << ", " << sec << ", " << nsec << ")" << std::endl;
 #endif
 
     Impl *adapter = lookupAdapter(handle);
     if (!adapter) return 0;
-    return adapter->process((Plugin *)handle,
-                            inputBuffers, sec, nsec);
+    return adapter->process((Plugin *)handle, inputBuffers, sec, nsec);
 }
 
 VampFeatureList *
 PluginAdapterBase::Impl::vampGetRemainingFeatures(VampPluginHandle handle)
 {

 }
 
 void 
 PluginAdapterBase::Impl::checkOutputMap(Plugin *plugin)
 {
-    if (m_pluginOutputs.find(plugin) == m_pluginOutputs.end() ||
-        !m_pluginOutputs[plugin]) {
+    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;
+    }
+}
+
+void
+PluginAdapterBase::Impl::markOutputsChanged(Plugin *plugin)
+{
+    OutputMap::iterator i = m_pluginOutputs.find(plugin);
+
+//    std::cerr << "PluginAdapterBase::Impl::markOutputsChanged" << std::endl;
+
+    if (i != m_pluginOutputs.end()) {
+
+        Plugin::OutputList *list = i->second;
+        m_pluginOutputs.erase(i);
+        delete list;
     }
 }
 
 unsigned int 
 PluginAdapterBase::Impl::getOutputCount(Plugin *plugin)
 {
     checkOutputMap(plugin);
+
     return m_pluginOutputs[plugin]->size();
 }
 
 VampOutputDescriptor *
 PluginAdapterBase::Impl::getOutputDescriptor(Plugin *plugin,
-                                       unsigned int i)
+                                             unsigned int i)
 {
     checkOutputMap(plugin);
+
     Plugin::OutputDescriptor &od =
         (*m_pluginOutputs[plugin])[i];
 
     VampOutputDescriptor *desc = (VampOutputDescriptor *)
         malloc(sizeof(VampOutputDescriptor));