c@118: /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
c@118: /*
c@118:   Piper C++
c@118: 
c@118:   An API for audio analysis and feature extraction plugins.
c@118: 
c@118:   Centre for Digital Music, Queen Mary, University of London.
c@118:   Copyright 2006-2016 Chris Cannam and QMUL.
c@118:   
c@118:   Permission is hereby granted, free of charge, to any person
c@118:   obtaining a copy of this software and associated documentation
c@118:   files (the "Software"), to deal in the Software without
c@118:   restriction, including without limitation the rights to use, copy,
c@118:   modify, merge, publish, distribute, sublicense, and/or sell copies
c@118:   of the Software, and to permit persons to whom the Software is
c@118:   furnished to do so, subject to the following conditions:
c@118: 
c@118:   The above copyright notice and this permission notice shall be
c@118:   included in all copies or substantial portions of the Software.
c@118: 
c@118:   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
c@118:   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
c@118:   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
c@118:   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
c@118:   ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
c@118:   CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
c@118:   WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
c@118: 
c@118:   Except as contained in this notice, the names of the Centre for
c@118:   Digital Music; Queen Mary, University of London; and Chris Cannam
c@118:   shall not be used in advertising or otherwise to promote the sale,
c@118:   use or other dealings in this Software without prior written
c@118:   authorization.
c@118: */
c@94: 
c@94: #ifndef PIPER_PLUGIN_STUB_H
c@94: #define PIPER_PLUGIN_STUB_H
c@94: 
c@94: #include <vamp-hostsdk/Plugin.h>
c@94: #include <vamp-hostsdk/PluginLoader.h>
c@97: 
c@97: #include "vamp-support/PluginStaticData.h"
c@97: #include "vamp-support/PluginConfiguration.h"
c@94: 
cannam@167: #include "PluginClient.h"
cannam@167: 
c@94: #include <cstdint>
cannam@167: #include <iostream>
c@94: 
c@97: namespace piper_vamp {
c@97: namespace client {
c@94: 
cannam@187: /**
cannam@187:  * PluginStub presents a Piper feature extractor in the form of a Vamp plugin.
cannam@187:  */
c@94: class PluginStub : public Vamp::Plugin
c@94: {
c@94:     enum State {
cannam@186:         /**
cannam@186:          * The plugin's corresponding Piper feature extractor has been
cannam@186:          * loaded but no subsequent state change has happened. This is
cannam@186:          * the initial state of PluginStub on construction, since it
cannam@186:          * is associated with a pre-loaded handle.
cannam@186:          */
cannam@186:         Loaded,
cannam@186:         
cannam@186:         /**
cannam@186:          * The plugin has been configured, and the step and block size
cannam@186:          * received from the host in its last call to initialise()
cannam@186:          * match those that were returned in the configuration
cannam@186:          * response (i.e. the server's desired step and block
cannam@186:          * size). Our m_config record reflects these correct
cannam@186:          * values. The plugin is ready to process.
cannam@186:          */
cannam@186:         Configured,
cannam@186: 
cannam@186:         /**
cannam@186:          * The plugin has been configured, but the step and block size
cannam@186:          * received from the host in its last call to initialise()
cannam@186:          * differ from those returned by the server in the
cannam@186:          * configuration response. Our initialise() call therefore
cannam@186:          * returned false, and the plugin cannot be used until the
cannam@186:          * host calls initialise() again with the "correct" step and
cannam@186:          * block size. Our m_config record reflects these correct
cannam@186:          * values, so the host can retrieve them through
cannam@186:          * getPreferredStepSize and getPreferredBlockSize.
cannam@186:          */
cannam@186:         Misconfigured,
cannam@186: 
cannam@186:         /**
cannam@186:          * The finish() function has been called and the plugin
cannam@186:          * unloaded. No further plugin activity is possible.
cannam@186:          */
cannam@186:         Finished,
cannam@186: 
cannam@186:         /** 
cannam@186:          * A call has failed unrecoverably. No further plugin activity
cannam@186:          * is possible.
cannam@186:          */
cannam@186:         Failed
c@94:     };
c@94:     
c@94: public:
c@94:     PluginStub(PluginClient *client,
c@94:                std::string pluginKey,
c@94:                float inputSampleRate,
c@94:                int adapterFlags,
c@97:                PluginStaticData psd,
c@97:                PluginConfiguration defaultConfig) :
c@94:         Plugin(inputSampleRate),
c@94:         m_client(client),
c@94:         m_key(pluginKey),
c@94:         m_adapterFlags(adapterFlags),
c@94:         m_state(Loaded),
c@94:         m_psd(psd),
c@94:         m_defaultConfig(defaultConfig),
c@94:         m_config(defaultConfig)
c@94:     { }
c@94: 
c@94:     virtual ~PluginStub() {
cannam@167:         if (m_state != Finished && m_state != Failed) {
cannam@167:             try {
cannam@167:                 (void)m_client->finish(this);
cannam@167:             } catch (const std::exception &e) {
cannam@167:                 // Finish can throw, but our destructor must not
cannam@167:                 std::cerr << "WARNING: PluginStub::~PluginStub: caught exception from finish(): " << e.what() << std::endl;
cannam@167:             }
c@94:         }
c@94:     }
c@94:     
c@94:     virtual std::string getIdentifier() const {
c@94:         return m_psd.basic.identifier;
c@94:     }
c@94: 
c@94:     virtual std::string getName() const {
c@94:         return m_psd.basic.name;
c@94:     }
c@94: 
c@94:     virtual std::string getDescription() const {
c@94:         return m_psd.basic.description;
c@94:     }
c@94: 
c@94:     virtual std::string getMaker() const {
c@94:         return m_psd.maker;
c@94:     }
c@94: 
c@94:     virtual std::string getCopyright() const {
c@94:         return m_psd.copyright;
c@94:     }
c@94: 
c@94:     virtual int getPluginVersion() const {
c@94:         return m_psd.pluginVersion;
c@94:     }
c@94: 
c@94:     virtual ParameterList getParameterDescriptors() const {
c@94:         return m_psd.parameters;
c@94:     }
c@94: 
c@94:     virtual float getParameter(std::string name) const {
c@94:         if (m_config.parameterValues.find(name) != m_config.parameterValues.end()) {
c@94:             return m_config.parameterValues.at(name);
c@94:         } else {
c@94:             return 0.f;
c@94:         }
c@94:     }
c@94: 
c@94:     virtual void setParameter(std::string name, float value) {
cannam@167:         if (m_state == Failed) {
cannam@167:             throw std::logic_error("Plugin is in failed state");
cannam@167:         }
c@94:         if (m_state != Loaded) {
cannam@167:             m_state = Failed;
c@94:             throw std::logic_error("Can't set parameter after plugin initialised");
c@94:         }
c@94:         m_config.parameterValues[name] = value;
c@94:     }
c@94: 
c@94:     virtual ProgramList getPrograms() const {
c@94:         return m_psd.programs;
c@94:     }
c@94: 
c@94:     virtual std::string getCurrentProgram() const {
c@94:         return m_config.currentProgram;
c@94:     }
c@94:     
c@94:     virtual void selectProgram(std::string program) {
cannam@167:         if (m_state == Failed) {
cannam@167:             throw std::logic_error("Plugin is in failed state");
cannam@167:         }
c@94:         if (m_state != Loaded) {
cannam@167:             m_state = Failed;
c@94:             throw std::logic_error("Can't select program after plugin initialised");
c@94:         }
c@94:         m_config.currentProgram = program;
c@94:     }
c@94: 
c@94:     virtual bool initialise(size_t inputChannels,
c@94:                             size_t stepSize,
c@94:                             size_t blockSize) {
c@94: 
cannam@167:         if (m_state == Failed) {
cannam@167:             throw std::logic_error("Plugin is in failed state");
cannam@167:         }
cannam@186: 
cannam@186:         if (m_state == Misconfigured) {
cannam@186:             if (int(stepSize) == m_config.framing.stepSize &&
cannam@186:                 int(blockSize) == m_config.framing.blockSize) {
cannam@186:                 m_state = Configured;
cannam@186:                 return true;
cannam@186:             } else {
cannam@186:                 return false;
cannam@186:             }
cannam@186:         }
cannam@186:         
c@94:         if (m_state != Loaded) {
cannam@167:             m_state = Failed;
c@94:             throw std::logic_error("Plugin has already been initialised");
c@94:         }
c@94:         
c@102:         m_config.channelCount = int(inputChannels);
cannam@185:         m_config.framing.stepSize = int(stepSize);
cannam@185:         m_config.framing.blockSize = int(blockSize);
c@94: 
cannam@169:         try {
cannam@185:             auto response = m_client->configure(this, m_config);
cannam@185:             m_outputs = response.outputs;
cannam@186:             
cannam@185:             // Update with the new preferred step and block size now
cannam@185:             // that the plugin has taken into account its parameter
cannam@185:             // settings. If the values passed in to initialise()
cannam@185:             // weren't suitable, then this ensures that a subsequent
cannam@185:             // call to getPreferredStepSize/BlockSize on this plugin
cannam@185:             // object will at least get acceptable values from now on
cannam@185:             m_config.framing = response.framing;
cannam@186: 
cannam@186:             // And if they didn't match up with the passed-in ones,
cannam@186:             // lodge ourselves in Misconfigured state and report
cannam@186:             // failure so as to provoke the host to call initialise()
cannam@186:             // again before any processing.
cannam@186:             if (m_config.framing.stepSize != int(stepSize) ||
cannam@186:                 m_config.framing.blockSize != int(blockSize)) {
cannam@186:                 m_state = Misconfigured;
cannam@186:                 return false;
cannam@186:             }
cannam@185:             
cannam@169:         } catch (const std::exception &e) {
cannam@169:             m_state = Failed;
cannam@169:             throw;
cannam@169:         }
c@94: 
c@94:         if (!m_outputs.empty()) {
c@94:             m_state = Configured;
c@94:             return true;
c@94:         } else {
c@94:             return false;
c@94:         }
c@94:     }
c@94: 
c@94:     virtual void reset() {
c@94:         
cannam@167:         if (m_state == Failed) {
cannam@167:             throw std::logic_error("Plugin is in failed state");
cannam@167:         }
cannam@186:         if (m_state == Loaded || m_state == Misconfigured) {
c@94:             // reset is a no-op if the plugin hasn't been initialised yet
c@94:             return;
c@94:         }
cannam@169: 
cannam@169:         try {
cannam@169:             m_client->reset(this, m_config);
cannam@169:         } catch (const std::exception &e) {
cannam@169:             m_state = Failed;
cannam@169:             throw;
cannam@169:         }
c@94: 
c@94:         m_state = Configured;
c@94:     }
c@94: 
c@94:     virtual InputDomain getInputDomain() const {
c@94:         return m_psd.inputDomain;
c@94:     }
c@94: 
c@94:     virtual size_t getPreferredBlockSize() const {
cannam@185:         // Return this from m_config instead of m_defaultConfig, so
cannam@185:         // that it gets updated in the event of an initialise() call
cannam@185:         // that fails for the wrong value
cannam@185:         return m_config.framing.blockSize;
c@94:     }
c@94: 
c@94:     virtual size_t getPreferredStepSize() const {
cannam@185:         // Return this from m_config instead of m_defaultConfig, so
cannam@185:         // that it gets updated in the event of an initialise() call
cannam@185:         // that fails for the wrong value
cannam@185:         return m_config.framing.stepSize;
c@94:     }
c@94: 
c@94:     virtual size_t getMinChannelCount() const {
c@94:         return m_psd.minChannelCount;
c@94:     }
c@94: 
c@94:     virtual size_t getMaxChannelCount() const {
c@94:         return m_psd.maxChannelCount;
c@94:     }
c@94: 
c@94:     virtual OutputList getOutputDescriptors() const {
cannam@167: 
cannam@167:         if (m_state == Failed) {
cannam@167:             throw std::logic_error("Plugin is in failed state");
cannam@167:         }
c@94:         if (m_state == Configured) {
c@94:             return m_outputs;
c@94:         }
c@94: 
c@94:         //!!! todo: figure out for which hosts (and adapters?) it may
c@94:         //!!! be a problem that the output descriptors are incomplete
c@94:         //!!! here. Any such hosts/adapters are broken, but I bet they
c@94:         //!!! exist
c@94:         
c@94:         OutputList staticOutputs;
c@94:         for (const auto &o: m_psd.basicOutputInfo) {
c@94:             OutputDescriptor od;
c@94:             od.identifier = o.identifier;
c@94:             od.name = o.name;
c@94:             od.description = o.description;
c@94:             staticOutputs.push_back(od);
c@94:         }
c@94:         return staticOutputs;
c@94:     }
c@94: 
c@94:     virtual FeatureSet process(const float *const *inputBuffers,
c@118:                                Vamp::RealTime timestamp) {
c@94: 
cannam@167:         if (m_state == Failed) {
cannam@167:             throw std::logic_error("Plugin is in failed state");
cannam@167:         }
cannam@186:         if (m_state == Loaded || m_state == Misconfigured) {
cannam@167:             m_state = Failed;
c@94:             throw std::logic_error("Plugin has not been initialised");
c@94:         }
c@94:         if (m_state == Finished) {
cannam@167:             m_state = Failed;
c@94:             throw std::logic_error("Plugin has already been disposed of");
c@94:         }
c@94: 
c@94:         std::vector<std::vector<float> > vecbuf;
c@94:         for (int c = 0; c < m_config.channelCount; ++c) {
c@94:             vecbuf.push_back(std::vector<float>
c@94:                              (inputBuffers[c],
cannam@185:                               inputBuffers[c] + m_config.framing.blockSize));
c@94:         }
cannam@169: 
cannam@169:         try {
cannam@169:             return m_client->process(this, vecbuf, timestamp);
cannam@169:         } catch (const std::exception &e) {
cannam@169:             m_state = Failed;
cannam@169:             throw;
cannam@169:         }
c@94:     }
c@94: 
c@94:     virtual FeatureSet getRemainingFeatures() {
c@94: 
cannam@167:         if (m_state == Failed) {
cannam@167:             throw std::logic_error("Plugin is in failed state");
cannam@167:         }
cannam@186:         if (m_state == Loaded || m_state == Misconfigured) {
cannam@167:             m_state = Failed;
c@94:             throw std::logic_error("Plugin has not been configured");
c@94:         }
c@94:         if (m_state == Finished) {
cannam@167:             m_state = Failed;
c@94:             throw std::logic_error("Plugin has already been disposed of");
c@94:         }
c@94: 
c@94:         m_state = Finished;
c@94: 
cannam@169:         try {
cannam@169:             return m_client->finish(this);
cannam@169:         } catch (const std::exception &e) {
cannam@169:             m_state = Failed;
cannam@169:             throw;
cannam@169:         }
c@94:     }
c@94: 
c@94:     // Not Plugin methods, but needed by the PluginClient to support reloads:
c@94:     
c@94:     virtual float getInputSampleRate() const {
c@94:         return m_inputSampleRate;
c@94:     }
c@94: 
c@94:     virtual std::string getPluginKey() const {
c@94:         return m_key;
c@94:     }
c@94: 
c@94:     virtual int getAdapterFlags() const {
c@94:         return m_adapterFlags;
c@94:     }
c@94:     
c@94: private:
c@94:     PluginClient *m_client;
c@94:     std::string m_key;
c@94:     int m_adapterFlags;
c@94:     State m_state;
c@97:     PluginStaticData m_psd;
c@94:     OutputList m_outputs;
c@97:     PluginConfiguration m_defaultConfig;
c@97:     PluginConfiguration m_config;
c@94: };
c@94: 
c@94: }
c@94: }
c@94: 
c@94: #endif