libs/vamp-sdk/vamp-hostsdk/PluginLoader.h

   1 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
   2
   3 /*
   4     Vamp
   5
   6     An API for audio analysis and feature extraction plugins.
   7
   8     Centre for Digital Music, Queen Mary, University of London.
   9     Copyright 2006-2007 Chris Cannam and QMUL.
  10
  11     Permission is hereby granted, free of charge, to any person
  12     obtaining a copy of this software and associated documentation
  13     files (the "Software"), to deal in the Software without
  14     restriction, including without limitation the rights to use, copy,
  15     modify, merge, publish, distribute, sublicense, and/or sell copies
  16     of the Software, and to permit persons to whom the Software is
  17     furnished to do so, subject to the following conditions:
  18
  19     The above copyright notice and this permission notice shall be
  20     included in all copies or substantial portions of the Software.
  21
  22     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
  26     ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
  27     CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29
  30     Except as contained in this notice, the names of the Centre for
  31     Digital Music; Queen Mary, University of London; and Chris Cannam
  32     shall not be used in advertising or otherwise to promote the sale,
  33     use or other dealings in this Software without prior written
  34     authorization.
  35 */
  36
  37 #ifndef _VAMP_PLUGIN_LOADER_H_
  38 #define _VAMP_PLUGIN_LOADER_H_
  39
  40 #include <vector>
  41 #include <string>
  42 #include <map>
  43
  44 #include "hostguard.h"
  45 #include "PluginWrapper.h"
  46
  47 _VAMP_SDK_HOSTSPACE_BEGIN(PluginLoader.h)
  48
  49 namespace Vamp {
  50
  51 class Plugin;
  52
  53 namespace HostExt {
  54
  55 /**
  56  * \class PluginLoader PluginLoader.h <vamp-hostsdk/PluginLoader.h>
  57  *
  58  * Vamp::HostExt::PluginLoader is a convenience class for discovering
  59  * and loading Vamp plugins using the typical plugin-path, library
  60  * naming, and categorisation conventions described in the Vamp SDK
  61  * documentation.  This class is intended to greatly simplify the task
  62  * of becoming a Vamp plugin host for any C++ application.
  63  *
  64  * Hosts are not required by the Vamp specification to use the same
  65  * plugin search path and naming conventions as implemented by this
  66  * class, and are certainly not required to use this actual class.
  67  * But we do strongly recommend it.
  68  *
  69  * \note This class was introduced in version 1.1 of the Vamp plugin SDK.
  70  */
  71
  72 class PluginLoader
  73 {
  74 public:
  75     /**
  76      * Obtain a pointer to the singleton instance of PluginLoader.
  77      * Use this to obtain your loader object.
  78      */
  79     static PluginLoader *getInstance();
  80
  81     /**
  82      * PluginKey is a string type that is used to identify a plugin
  83      * uniquely within the scope of "the current system".  It consists
  84      * of the lower-cased base name of the plugin library, a colon
  85      * separator, and the identifier string for the plugin.  It is
  86      * only meaningful in the context of a given plugin path (the one
  87      * returned by PluginHostAdapter::getPluginPath()).
  88      *
  89      * Use composePluginKey() to construct a plugin key from a known
  90      * plugin library name and identifier.
  91      *
  92      * Note: the fact that the library component of the key is
  93      * lower-cased implies that library names are matched
  94      * case-insensitively by the PluginLoader class, regardless of the
  95      * case sensitivity of the underlying filesystem.  (Plugin
  96      * identifiers _are_ case sensitive, however.)  Also, it is not
  97      * possible to portably extract a working library name from a
  98      * plugin key, as the result may fail on case-sensitive
  99      * filesystems.  Use getLibraryPathForPlugin() instead.
 100      */
 101     typedef std::string PluginKey;
 102
 103     /**
 104      * PluginKeyList is a sequence of plugin keys, such as returned by
 105      * listPlugins().
 106      */
 107     typedef std::vector<PluginKey> PluginKeyList;
 108
 109     /**
 110      * PluginCategoryHierarchy is a sequence of general->specific
 111      * category names, as may be associated with a single plugin.
 112      * This sequence describes the location of a plugin within a
 113      * category forest, containing the human-readable names of the
 114      * plugin's category tree root, followed by each of the nodes down
 115      * to the leaf containing the plugin.
 116      *
 117      * \see getPluginCategory()
 118      */
 119     typedef std::vector<std::string> PluginCategoryHierarchy;
 120
 121     /**
 122      * Search for all available Vamp plugins, and return a list of
 123      * them in the order in which they were found.
 124      */
 125     PluginKeyList listPlugins();
 126
 127     /**
 128      * AdapterFlags contains a set of values that may be OR'd together
 129      * to indicate in which circumstances PluginLoader should use a
 130      * plugin adapter to make a plugin easier to use for a host that
 131      * does not want to cater for complex features.
 132      *
 133      * The available flags are:
 134      *
 135      * ADAPT_INPUT_DOMAIN - If the plugin expects frequency domain
 136      * input, wrap it in a PluginInputDomainAdapter that automatically
 137      * converts the plugin to one that expects time-domain input.
 138      * This enables a host to accommodate time- and frequency-domain
 139      * plugins without needing to do any conversion itself.
 140      *
 141      * ADAPT_CHANNEL_COUNT - Wrap the plugin in a PluginChannelAdapter
 142      * to handle any mismatch between the number of channels of audio
 143      * the plugin can handle and the number available in the host.
 144      * This enables a host to use plugins that may require the input
 145      * to be mixed down to mono, etc., without having to worry about
 146      * doing that itself.
 147      *
 148      * ADAPT_BUFFER_SIZE - Wrap the plugin in a PluginBufferingAdapter
 149      * permitting the host to provide audio input using any block
 150      * size, with no overlap, regardless of the plugin's preferred
 151      * block size (suitable for hosts that read from non-seekable
 152      * streaming media, for example).  This adapter introduces some
 153      * run-time overhead and also changes the semantics of the plugin
 154      * slightly (see the PluginBufferingAdapter header documentation
 155      * for details).
 156      *
 157      * ADAPT_ALL_SAFE - Perform all available adaptations that are
 158      * meaningful for the plugin and "safe".  Currently this means to
 159      * ADAPT_INPUT_DOMAIN if the plugin wants FrequencyDomain input;
 160      * ADAPT_CHANNEL_COUNT always; and ADAPT_BUFFER_SIZE never.
 161      *
 162      * ADAPT_ALL - Perform all available adaptations that are
 163      * meaningful for the plugin.
 164      *
 165      * See PluginInputDomainAdapter, PluginChannelAdapter and
 166      * PluginBufferingAdapter for more details of the classes that the
 167      * loader may use if these flags are set.
 168      */
 169     enum AdapterFlags {
 170
 171         ADAPT_INPUT_DOMAIN  = 0x01,
 172         ADAPT_CHANNEL_COUNT = 0x02,
 173         ADAPT_BUFFER_SIZE   = 0x04,
 174
 175         ADAPT_ALL_SAFE      = 0x03,
 176
 177         ADAPT_ALL           = 0xff
 178     };
 179
 180     /**
 181      * Load a Vamp plugin, given its identifying key.  If the plugin
 182      * could not be loaded, returns 0.
 183      *
 184      * The returned plugin should be deleted (using the standard C++
 185      * delete keyword) after use.
 186      *
 187      * \param adapterFlags a bitwise OR of the values in the AdapterFlags
 188      * enumeration, indicating under which circumstances an adapter should be
 189      * used to wrap the original plugin.  If adapterFlags is 0, no
 190      * optional adapters will be used.  Otherwise, the returned plugin
 191      * may be of an adapter class type which will behave identically
 192      * to the original plugin, apart from any particular features
 193      * implemented by the adapter itself.
 194      *
 195      * \see AdapterFlags, PluginInputDomainAdapter, PluginChannelAdapter
 196      */
 197     Plugin *loadPlugin(PluginKey key,
 198                        float inputSampleRate,
 199                        int adapterFlags = 0);
 200
 201     /**
 202      * Given a Vamp plugin library name and plugin identifier, return
 203      * the corresponding plugin key in a form suitable for passing in to
 204      * loadPlugin().
 205      */
 206     PluginKey composePluginKey(std::string libraryName,
 207                                std::string identifier);
 208
 209     /**
 210      * Return the category hierarchy for a Vamp plugin, given its
 211      * identifying key.
 212      *
 213      * If the plugin has no category information, return an empty
 214      * hierarchy.
 215      *
 216      * \see PluginCategoryHierarchy
 217      */
 218     PluginCategoryHierarchy getPluginCategory(PluginKey plugin);
 219
 220     /**
 221      * Return the file path of the dynamic library from which the
 222      * given plugin will be loaded (if available).
 223      */
 224     std::string getLibraryPathForPlugin(PluginKey plugin);
 225
 226 protected:
 227     PluginLoader();
 228     virtual ~PluginLoader();
 229
 230     class Impl;
 231     Impl *m_impl;
 232
 233     static PluginLoader *m_instance;
 234 };
 235
 236 }
 237
 238 }
 239
 240 _VAMP_SDK_HOSTSPACE_END(PluginLoader.h)
 241
 242 #endif
 243