change: Switch to offical OpenFX Support. Still can't compile.

third_party/openfx/HostSupport/include/ofxhImageEffectAPI.h

@@ -0,0 +1,221 @@
+
+
+
+#ifndef OFXH_IMAGE_EFFECT_API_H
+#define OFXH_IMAGE_EFFECT_API_H
+
+#include "ofxhPluginAPICache.h"
+#include "ofxhPluginCache.h"
+#include <string>
+#include <map>
+#include <set>
+#include <memory>
+#include <utility>
+
+#include "ofxCore.h"
+#include "ofxImageEffect.h"
+#include "ofxhImageEffect.h"
+#include "ofxhHost.h"
+
+  
+  
+    
+    namespace OFX::Host::ImageEffect {
+
+      class PluginCache;
+
+      /// subclass of Plugin representing an ImageEffect plugin.  used to store API-specific
+      /// data
+      class ImageEffectPlugin : public Plugin {
+
+        PluginCache &_pc;
+
+        // this comes off Descriptor's property set after a describe
+        // context independent
+        Descriptor *_baseDescriptor; /// NEEDS TO BE MADE WITH A FACTORY FUNCTION ON THE HOST!!!!!!
+        
+        /// map to store contexts in
+        std::map<std::string, std::unique_ptr<Descriptor>> _contexts;
+
+        mutable std::set<std::string> _knownContexts;
+        mutable bool _madeKnownContexts;
+
+        std::unique_ptr<PluginHandle> _pluginHandle;
+
+        void addContextInternal(const std::string &context) const;
+
+      public:
+			  ImageEffectPlugin(PluginCache &pc, PluginBinary *pb, int pi, OfxPlugin *pl);
+
+        ImageEffectPlugin(PluginCache &pc,
+                          PluginBinary *pb,
+                          int pi,
+                          const std::string &api,
+                          int apiVersion,
+                          const std::string &pluginId,
+                          const std::string &rawId,
+                          int pluginMajorVersion,
+                          int pluginMinorVersion);
+
+        ~ImageEffectPlugin() override;
+
+        /// return the API handler this plugin was constructed by
+        APICache::PluginAPICacheI &getApiHandler() override;
+
+
+        /// get the base image effect descriptor
+        Descriptor &getDescriptor();
+
+        /// get the base image effect descriptor, const version
+        const Descriptor &getDescriptor() const;
+
+        /// get the image effect descriptor for the context
+        Descriptor *getContext(const std::string &context);
+
+        void addContext(const std::string &context);
+        void addContext(const std::string &context, std::unique_ptr<Descriptor> ied);
+
+        virtual void saveXML(std::ostream &os);
+
+        const std::set<std::string>& getContexts() const;
+
+        PluginHandle *getPluginHandle();
+
+        void unload();
+
+        /// this is called to make an instance of the effect
+        /// the client data ptr is what is passed back to the client creation function
+        ImageEffect::Instance* createInstance(const std::string &context, void *clientDataPtr);
+
+      };
+
+      class MajorPlugin {
+        std::string _id;
+        int _major;
+
+      public:
+        MajorPlugin(std::string id, int major) : _id(std::move(id)), _major(major) {
+        }
+
+        explicit MajorPlugin(ImageEffectPlugin *iep) : _id(iep->getIdentifier()), _major(iep->getVersionMajor()) {
+        }
+
+        [[nodiscard]] const std::string &getId() const {
+          return _id;
+        }
+
+        [[nodiscard]] int getMajor() const {
+          return _major;
+        }
+
+        bool operator<(const MajorPlugin &other) const {
+          if (_id < other._id)
+            return true;
+
+          if (_id > other._id)
+            return false;
+          
+          if (_major < other._major)
+            return true;
+
+          return false;
+        }
+      };
+
+      /// implementation of the specific Image Effect handler API cache.
+      class PluginCache : public APICache::PluginAPICacheI {
+      public:      
+
+      private:
+        /// all plugins
+        std::vector<ImageEffectPlugin *> _plugins;
+
+        /// latest version of each plugin by ID
+        std::map<std::string, ImageEffectPlugin *> _pluginsByID;
+
+        /// latest minor version of each plugin by (ID,major)
+        std::map<MajorPlugin, ImageEffectPlugin *> _pluginsByIDMajor;
+
+        /// xml parsing state
+        ImageEffectPlugin *_currentPlugin;
+        /// xml parsing state
+        Property::Property *_currentProp;
+        
+        Descriptor *_currentContext;
+        Param::Descriptor *_currentParam;
+        ClipDescriptor *_currentClip;
+
+        /// pointer to our image effect host
+        OFX::Host::ImageEffect::Host* _host;
+
+      public:  
+
+        explicit PluginCache(OFX::Host::ImageEffect::Host &host);
+
+        ~PluginCache() override;        
+
+        /// get the plugin by id.  vermaj and vermin can be specified.  if they are not it will
+        /// pick the highest found version.
+        ImageEffectPlugin *getPluginById(const std::string &id, int vermaj=-1, int vermin=-1);
+
+        /// get the plugin by label.  vermaj and vermin can be specified.  if they are not it will
+        /// pick the highest found version.
+        ImageEffectPlugin *getPluginByLabel(const std::string &label, int vermaj=-1, int vermin=-1);
+
+        OFX::Host::ImageEffect::Host *getHost() {
+          return _host;
+        }
+
+        [[nodiscard]] const std::vector<ImageEffectPlugin *>& getPlugins() const;
+
+        [[nodiscard]] const std::map<std::string, ImageEffectPlugin *>& getPluginsByID() const;
+
+        [[nodiscard]] const std::map<MajorPlugin, ImageEffectPlugin *>& getPluginsByIDMajor() const
+        {
+          return _pluginsByIDMajor;
+        }
+
+        /// handle the case where the info needs filling in from the file.  runs the "describe" action on the plugin.
+        void loadFromPlugin(Plugin *p) const override;
+        
+        /// handler for preparing to read in a chunk of XML from the cache, set up context to do this
+        void beginXmlParsing(Plugin *p) override;
+
+        /// XML handler : element begins (everything is stored in elements and attributes)       
+        void xmlElementBegin(const std::string &el, std::map<std::string, std::string> map) override;
+
+        void xmlCharacterHandler(const std::string &) override;
+        
+        void xmlElementEnd(const std::string &el) override;
+        
+        void endXmlParsing() override;
+        
+        void saveXML(Plugin *ip, std::ostream &os) const override;
+
+        void confirmPlugin(Plugin *p) override;
+
+        bool pluginSupported(Plugin *p, std::string &reason) const override;
+
+        Plugin *newPlugin(PluginBinary *pb,
+                          int pi,
+                          OfxPlugin *pl) override;
+
+        Plugin *newPlugin(PluginBinary *pb,
+                          int pi,
+                          const std::string &api,
+                          int apiVersion,
+                          const std::string &pluginId,
+                          const std::string &rawId,
+                          int pluginMajorVersion,
+                          int pluginMinorVersion) override;
+
+        void dumpToStdOut();
+      };
+    
+    } // ImageEffect
+
+  // Host
+
+// OFX
+
+#endif