comparison vamp-client/PluginStub.h @ 167:4a37daf5f8b4

Add a failed state to the plugin stub, to prevent it making any further
requests after (for example) a process has timed out

 #include <vamp-hostsdk/PluginLoader.h>
 
 #include "vamp-support/PluginStaticData.h"
 #include "vamp-support/PluginConfiguration.h"
 
+#include "PluginClient.h"
+
 #include <cstdint>
-
-#include "PluginClient.h"
+#include <iostream>
 
 namespace piper_vamp {
 namespace client {
 
 class PluginStub : public Vamp::Plugin
 {
     enum State {
-        Loaded, Configured, Finished
+        Loaded, Configured, Finished, Failed
     };
     
 public:
     PluginStub(PluginClient *client,
                std::string pluginKey,

         m_defaultConfig(defaultConfig),
         m_config(defaultConfig)
     { }
 
     virtual ~PluginStub() {
-        if (m_state != Finished) {
-            (void)m_client->finish(this);
+        if (m_state != Finished && m_state != Failed) {
+            try {
+                (void)m_client->finish(this);
+            } catch (const std::exception &e) {
+                // Finish can throw, but our destructor must not
+                std::cerr << "WARNING: PluginStub::~PluginStub: caught exception from finish(): " << e.what() << std::endl;
+            }
         }
     }
     
     virtual std::string getIdentifier() const {
         return m_psd.basic.identifier;

             return 0.f;
         }
     }
 
     virtual void setParameter(std::string name, float value) {
+        if (m_state == Failed) {
+            throw std::logic_error("Plugin is in failed state");
+        }
         if (m_state != Loaded) {
+            m_state = Failed;
             throw std::logic_error("Can't set parameter after plugin initialised");
         }
         m_config.parameterValues[name] = value;
     }
 

     virtual std::string getCurrentProgram() const {
         return m_config.currentProgram;
     }
     
     virtual void selectProgram(std::string program) {
+        if (m_state == Failed) {
+            throw std::logic_error("Plugin is in failed state");
+        }
         if (m_state != Loaded) {
+            m_state = Failed;
             throw std::logic_error("Can't select program after plugin initialised");
         }
         m_config.currentProgram = program;
     }
 
     virtual bool initialise(size_t inputChannels,
                             size_t stepSize,
                             size_t blockSize) {
 
+        if (m_state == Failed) {
+            throw std::logic_error("Plugin is in failed state");
+        }
         if (m_state != Loaded) {
+            m_state = Failed;
             throw std::logic_error("Plugin has already been initialised");
         }
         
         m_config.channelCount = int(inputChannels);
         m_config.stepSize = int(stepSize);

         }
     }
 
     virtual void reset() {
         
+        if (m_state == Failed) {
+            throw std::logic_error("Plugin is in failed state");
+        }
         if (m_state == Loaded) {
             // reset is a no-op if the plugin hasn't been initialised yet
             return;
         }
         

     virtual size_t getMaxChannelCount() const {
         return m_psd.maxChannelCount;
     }
 
     virtual OutputList getOutputDescriptors() const {
+
+        if (m_state == Failed) {
+            throw std::logic_error("Plugin is in failed state");
+        }
         if (m_state == Configured) {
             return m_outputs;
         }
 
         //!!! todo: figure out for which hosts (and adapters?) it may

     }
 
     virtual FeatureSet process(const float *const *inputBuffers,
                                Vamp::RealTime timestamp) {
 
+        if (m_state == Failed) {
+            throw std::logic_error("Plugin is in failed state");
+        }
         if (m_state == Loaded) {
+            m_state = Failed;
             throw std::logic_error("Plugin has not been initialised");
         }
         if (m_state == Finished) {
+            m_state = Failed;
             throw std::logic_error("Plugin has already been disposed of");
         }
 
         //!!! ew
         std::vector<std::vector<float> > vecbuf;

         return m_client->process(this, vecbuf, timestamp);
     }
 
     virtual FeatureSet getRemainingFeatures() {
 
+        if (m_state == Failed) {
+            throw std::logic_error("Plugin is in failed state");
+        }
         if (m_state == Loaded) {
+            m_state = Failed;
             throw std::logic_error("Plugin has not been configured");
         }
         if (m_state == Finished) {
+            m_state = Failed;
             throw std::logic_error("Plugin has already been disposed of");
         }
 
         m_state = Finished;