comparison plugin/transform/TransformerFactory.h @ 329:3179d8b29336

* Another incremental Transform update

 */
 
 #ifndef _TRANSFORMER_FACTORY_H_
 #define _TRANSFORMER_FACTORY_H_
 
+#include "TransformDescription.h"
+
 #include "Transformer.h"
 #include "PluginTransformer.h"
 
 #include <map>
 #include <set>
 
 namespace Vamp { class PluginBase; }
 
 class AudioCallbackPlaySource;
 
+//!!! split into TransformFactory (information about available
+// transforms, create default Transform for each transform ID etc) and
+// TransformerFactory (create Transformers to apply transforms)
+
 class TransformerFactory : public QObject
 {
     Q_OBJECT
 
 public:
     virtual ~TransformerFactory();
 
     static TransformerFactory *getInstance();
 
-    // The identifier is intended to be computer-referenceable, and
-    // unique within the application.  The name is intended to be
-    // human readable.  In principle it doesn't have to be unique, but
-    // the factory will add suffixes to ensure that it is, all the
-    // same (just to avoid user confusion).  The friendly name is a
-    // shorter version of the name.  The type is also intended to be
-    // user-readable, for use in menus.
-
-    struct TransformerDesc {
-
-        TransformerDesc() { }
-	TransformerDesc(QString _type, QString _category,
-                      TransformerId _identifier, QString _name,
-                      QString _friendlyName, QString _description,
-                      QString _maker, QString _units, bool _configurable) :
-	    type(_type), category(_category),
-            identifier(_identifier), name(_name),
-            friendlyName(_friendlyName), description(_description),
-            maker(_maker), units(_units), configurable(_configurable) { }
-
-        QString type; // e.g. feature extraction plugin
-        QString category; // e.g. time > onsets
-	TransformerId identifier; // e.g. vamp:vamp-aubio:aubioonset
-	QString name; // plugin's name if 1 output, else "name: output"
-        QString friendlyName; // short text for layer name
-        QString description; // sentence describing transform
-        QString maker;
-        QString units;
-        bool configurable;
-
-        bool operator<(const TransformerDesc &od) const {
-            return (name < od.name);
-        };
-    };
-    typedef std::vector<TransformerDesc> TransformerList;
-
-    TransformerList getAllTransformers();
+    TransformList getAllTransforms();
 
     std::vector<QString> getAllTransformerTypes();
 
     std::vector<QString> getTransformerCategories(QString transformType);
     std::vector<QString> getTransformerMakers(QString transformType);

      * asking the user, most likely).  Returns the selected input
      * model if the transform is acceptable, 0 if the operation should
      * be cancelled.  Audio callback play source may be used to
      * audition effects plugins, if provided.
      */
-    Model *getConfigurationForTransformer(TransformerId identifier,
+    Model *getConfigurationForTransformer(TransformId identifier,
                                         const std::vector<Model *> &candidateInputModels,
                                         PluginTransformer::ExecutionContext &context,
                                         QString &configurationXml,
                                         AudioCallbackPlaySource *source = 0,
                                         size_t startFrame = 0,

 
     /**
      * Get the default execution context for the given transform
      * and input model (if known).
      */
-    PluginTransformer::ExecutionContext getDefaultContextForTransformer(TransformerId identifier,
+    PluginTransformer::ExecutionContext getDefaultContextForTransformer(TransformId identifier,
                                                                     Model *inputModel = 0);
 
     /**
      * Return the output model resulting from applying the named
      * transform to the given input model.  The transform may still be

      * problem occurs, return 0.
      * 
      * The returned model is owned by the caller and must be deleted
      * when no longer needed.
      */
-    Model *transform(TransformerId identifier, Model *inputModel,
+    Model *transform(TransformId identifier, Model *inputModel,
                      const PluginTransformer::ExecutionContext &context,
                      QString configurationXml = "");
 
     /**
      * Return true if the given transform is known.
      */
-    bool haveTransformer(TransformerId identifier);
+    bool haveTransformer(TransformId identifier);
 
     /**
      * Full name of a transform, suitable for putting on a menu.
      */
-    QString getTransformerName(TransformerId identifier);
+    QString getTransformerName(TransformId identifier);
 
     /**
      * Brief but friendly name of a transform, suitable for use
      * as the name of the output layer.
      */
-    QString getTransformerFriendlyName(TransformerId identifier);
+    QString getTransformerFriendlyName(TransformId identifier);
 
-    QString getTransformerUnits(TransformerId identifier);
+    QString getTransformerUnits(TransformId identifier);
 
     /**
      * Return true if the transform has any configurable parameters,
      * i.e. if getConfigurationForTransformer can ever return a non-trivial
      * (not equivalent to empty) configuration string.
      */
-    bool isTransformerConfigurable(TransformerId identifier);
+    bool isTransformerConfigurable(TransformId identifier);
 
     /**
      * If the transform has a prescribed number or range of channel
      * inputs, return true and set minChannels and maxChannels to the
      * minimum and maximum number of channel inputs the transform can
      * accept.  Return false if it doesn't care.
      */
-    bool getTransformerChannelRange(TransformerId identifier,
+    bool getTransformerChannelRange(TransformId identifier,
                                   int &minChannels, int &maxChannels);
 	
 protected slots:
     void transformFinished();
 
     void modelAboutToBeDeleted(Model *);
 
 protected:
-    Transformer *createTransformer(TransformerId identifier, Model *inputModel,
+    Transformer *createTransformer(TransformId identifier, Model *inputModel,
                                const PluginTransformer::ExecutionContext &context,
                                QString configurationXml);
 
-    struct TransformerIdent
+    struct TransformIdent
     {
-        TransformerId identifier;
+        TransformId identifier;
         QString configurationXml;
     };
 
-    typedef std::map<TransformerId, QString> TransformerConfigurationMap;
+    typedef std::map<TransformId, QString> TransformerConfigurationMap;
     TransformerConfigurationMap m_lastConfigurations;
 
-    typedef std::map<TransformerId, TransformerDesc> TransformerDescriptionMap;
-    TransformerDescriptionMap m_transforms;
+    typedef std::map<TransformId, TransformDescription> TransformDescriptionMap;
+    TransformDescriptionMap m_transforms;
 
     typedef std::set<Transformer *> TransformerSet;
     TransformerSet m_runningTransformers;
 
-    void populateTransformers();
-    void populateFeatureExtractionPlugins(TransformerDescriptionMap &);
-    void populateRealTimePlugins(TransformerDescriptionMap &);
+    void populateTransforms();
+    void populateFeatureExtractionPlugins(TransformDescriptionMap &);
+    void populateRealTimePlugins(TransformDescriptionMap &);
 
-    bool getChannelRange(TransformerId identifier,
+    bool getChannelRange(TransformId identifier,
                          Vamp::PluginBase *plugin, int &min, int &max);
 
     static TransformerFactory *m_instance;
 };