comparison vamp-client/PluginStub.h @ 186:52322dde68ea

Fix erroneous logic for handling step and block size in prior commit

The earlier change had a logical misconception. If PluginStub is
receiving the correct step and block size back from the configure call,
the plugin on the server side must have already been successfully
initialised, as the step and block size are only returned in a
successful configure response. This means the test for a failed
initialise and redo with the correct parameters must be done on the
server side (in LoaderRequests) not the client. The client has a more
complicated job, which is to notice that a *successful* configure had
returned different framing parameters from those passed to the
initialise call, and to pretend that it had actually failed until the
host called again with the correct parameters. We definitely need tests
for this!

 namespace client {
 
 class PluginStub : public Vamp::Plugin
 {
     enum State {
-        Loaded, Configured, Finished, Failed
+        /**
+         * The plugin's corresponding Piper feature extractor has been
+         * loaded but no subsequent state change has happened. This is
+         * the initial state of PluginStub on construction, since it
+         * is associated with a pre-loaded handle.
+         */
+        Loaded,
+        
+        /**
+         * The plugin has been configured, and the step and block size
+         * received from the host in its last call to initialise()
+         * match those that were returned in the configuration
+         * response (i.e. the server's desired step and block
+         * size). Our m_config record reflects these correct
+         * values. The plugin is ready to process.
+         */
+        Configured,
+
+        /**
+         * The plugin has been configured, but the step and block size
+         * received from the host in its last call to initialise()
+         * differ from those returned by the server in the
+         * configuration response. Our initialise() call therefore
+         * returned false, and the plugin cannot be used until the
+         * host calls initialise() again with the "correct" step and
+         * block size. Our m_config record reflects these correct
+         * values, so the host can retrieve them through
+         * getPreferredStepSize and getPreferredBlockSize.
+         */
+        Misconfigured,
+
+        /**
+         * The finish() function has been called and the plugin
+         * unloaded. No further plugin activity is possible.
+         */
+        Finished,
+
+        /** 
+         * A call has failed unrecoverably. No further plugin activity
+         * is possible.
+         */
+        Failed
     };
     
 public:
     PluginStub(PluginClient *client,
                std::string pluginKey,

                             size_t blockSize) {
 
         if (m_state == Failed) {
             throw std::logic_error("Plugin is in failed state");
         }
+
+        if (m_state == Misconfigured) {
+            if (int(stepSize) == m_config.framing.stepSize &&
+                int(blockSize) == m_config.framing.blockSize) {
+                m_state = Configured;
+                return true;
+            } else {
+                return false;
+            }
+        }
+        
         if (m_state != Loaded) {
             m_state = Failed;
             throw std::logic_error("Plugin has already been initialised");
         }
         

         m_config.framing.blockSize = int(blockSize);
 
         try {
             auto response = m_client->configure(this, m_config);
             m_outputs = response.outputs;
-
+            
             // Update with the new preferred step and block size now
             // that the plugin has taken into account its parameter
             // settings. If the values passed in to initialise()
             // weren't suitable, then this ensures that a subsequent
             // call to getPreferredStepSize/BlockSize on this plugin
             // object will at least get acceptable values from now on
             m_config.framing = response.framing;
+
+            // And if they didn't match up with the passed-in ones,
+            // lodge ourselves in Misconfigured state and report
+            // failure so as to provoke the host to call initialise()
+            // again before any processing.
+            if (m_config.framing.stepSize != int(stepSize) ||
+                m_config.framing.blockSize != int(blockSize)) {
+                m_state = Misconfigured;
+                return false;
+            }
             
         } catch (const std::exception &e) {
             m_state = Failed;
             throw;
         }

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

                                Vamp::RealTime timestamp) {
 
         if (m_state == Failed) {
             throw std::logic_error("Plugin is in failed state");
         }
-        if (m_state == Loaded) {
+        if (m_state == Loaded || m_state == Misconfigured) {
             m_state = Failed;
             throw std::logic_error("Plugin has not been initialised");
         }
         if (m_state == Finished) {
             m_state = Failed;

     virtual FeatureSet getRemainingFeatures() {
 
         if (m_state == Failed) {
             throw std::logic_error("Plugin is in failed state");
         }
-        if (m_state == Loaded) {
+        if (m_state == Loaded || m_state == Misconfigured) {
             m_state = Failed;
             throw std::logic_error("Plugin has not been configured");
         }
         if (m_state == Finished) {
             m_state = Failed;