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

2025-09-03 21:14:56 +08:00
parent 7ff76427f9
commit b649b5e1bd
198 changed files with 57444 additions and 980 deletions
@@ -0,0 +1,444 @@
+
+
+// ofx
+#include "ofxKeySyms.h"
+#include "ofxCore.h"
+#include "ofxImageEffect.h"
+
+// ofx host
+#include "ofxhBinary.h"
+#include "ofxhPropertySuite.h"
+#include "ofxhClip.h"
+#include "ofxhParam.h"
+#include "ofxhMemory.h"
+#include "ofxhImageEffect.h"
+#include "ofxhInteract.h"
+#include "ofxOld.h" // old plugins may rely on deprecated properties being present
+
+namespace OFX {
+
+  namespace Host {
+
+    namespace Interact {
+
+      //
+      // descriptor
+      //
+      static const Property::PropSpec interactDescriptorStuffs[] = {
+        { kOfxInteractPropHasAlpha , Property::eInt, 1, true, "0" },
+        { kOfxInteractPropBitDepth , Property::eInt, 1, true, "0" },
+        Property::propSpecEnd
+      };
+
+      Descriptor::Descriptor()
+        : _properties(interactDescriptorStuffs) 
+        , _state(eUninitialised)
+        , _entryPoint(NULL)
+      {
+      }
+
+      Descriptor::~Descriptor()
+      {
+      }
+
+      /// call describe on this descriptor
+      bool Descriptor::describe(int bitDepthPerComponent, bool hasAlpha)
+      {
+        if(_state == eUninitialised) {
+          _properties.setIntProperty(kOfxInteractPropBitDepth, bitDepthPerComponent);
+          _properties.setIntProperty(kOfxInteractPropHasAlpha, (int)(hasAlpha));
+
+          OfxStatus stat = callEntry(kOfxActionDescribe, getHandle(), NULL, NULL);
+          if(stat == kOfxStatOK || stat == kOfxStatReplyDefault) {
+            _state = eDescribed;
+          }
+          else {
+            _state = eFailed;
+          }
+        }
+        return _state == eDescribed;
+      }
+
+      // call the interactive entry point
+      OfxStatus Descriptor::callEntry(const char *action, 
+                                      void *handle,
+                                      OfxPropertySetHandle inArgs, 
+                                      OfxPropertySetHandle outArgs)
+      {
+        if(_entryPoint && _state != eFailed) {
+          return _entryPoint(action, handle, inArgs, outArgs);
+        }
+        else
+          return kOfxStatFailed;
+        
+        return kOfxStatOK;
+      }
+
+
+      ////////////////////////////////////////////////////////////////////////////////
+      static const Property::PropSpec interactInstanceStuffs[] = {
+        { kOfxPropEffectInstance, Property::ePointer, 1, true, NULL },
+        { kOfxPropInstanceData, Property::ePointer, 1, false, NULL },
+        { kOfxInteractPropPixelScale, Property::eDouble, 2, true, "1.0f" },
+        { kOfxInteractPropBackgroundColour , Property::eDouble, 3, true, "0.0f" },
+#ifdef kOfxInteractPropViewportSize // removed in OFX 1.4
+        { kOfxInteractPropViewportSize, Property::eDouble, 2, true, "100.0f" },
+#endif
+        { kOfxInteractPropSlaveToParam , Property::eString, 0, false, ""},
+        { kOfxInteractPropSuggestedColour , Property::eDouble, 3, true, "1.0f" },
+        Property::propSpecEnd
+      };
+
+      static const Property::PropSpec interactArgsStuffs[] = {
+        { kOfxPropEffectInstance, Property::ePointer, 1, false, NULL },
+        { kOfxPropTime, Property::eDouble, 1, false, "0.0" },
+        { kOfxImageEffectPropRenderScale, Property::eDouble, 2, false, "0.0" },
+        { kOfxInteractPropBackgroundColour , Property::eDouble, 3, false, "0.0f" },
+#ifdef kOfxInteractPropViewportSize // removed in OFX 1.4
+        { kOfxInteractPropViewportSize, Property::eDouble, 2, false, "0.0f" },
+#endif
+        { kOfxInteractPropPixelScale, Property::eDouble, 2, false, "1.0f" },
+        { kOfxInteractPropPenPosition, Property::eDouble, 2, false, "0.0" },
+        { kOfxInteractPropPenViewportPosition, Property::eInt, 2, false, "0" }, // new in OFX 1.2
+        { kOfxInteractPropPenPressure, Property::eDouble, 1, false, "0.0" },
+        { kOfxPropKeyString, Property::eString, 1, false, "" },
+        { kOfxPropKeySym, Property::eInt, 1, false, "0" },
+        Property::propSpecEnd
+      };
+
+      // instance
+
+      Instance::Instance(Descriptor& desc, void *effectInstance) 
+        : _descriptor(desc)
+        , _properties(interactInstanceStuffs)
+        , _state(desc.getState())
+        , _effectInstance(effectInstance)
+        , _argProperties(interactArgsStuffs)
+      {
+        _properties.setPointerProperty(kOfxPropEffectInstance, effectInstance);
+        _properties.setChainedSet(&desc.getProperties()); /// chain it into the descriptor props
+        _properties.setGetHook(kOfxInteractPropPixelScale, this);
+        _properties.setGetHook(kOfxInteractPropBackgroundColour,this);
+#ifdef kOfxInteractPropViewportSize // removed in OFX 1.4
+        _properties.setGetHook(kOfxInteractPropViewportSize,this);
+#endif
+        _properties.setGetHook(kOfxInteractPropSuggestedColour,this);
+
+        _argProperties.setGetHook(kOfxInteractPropPixelScale, this);
+        _argProperties.setGetHook(kOfxInteractPropBackgroundColour,this);
+#ifdef kOfxInteractPropViewportSize // removed in OFX 1.4
+        _argProperties.setGetHook(kOfxInteractPropViewportSize,this);
+#endif
+      }
+
+      Instance::~Instance()
+      {
+        /// call it directly incase CI failed and we should always tidy up after create instance
+        callEntry(kOfxActionDestroyInstance,  NULL);
+      }
+
+      /// call the entry point in the descriptor with action and the given args
+      OfxStatus Instance::callEntry(const char *action, Property::Set *inArgs)
+      {
+        if(_state != eFailed) {
+          OfxPropertySetHandle inHandle = inArgs ? inArgs->getHandle() : NULL ;
+          return _descriptor.callEntry(action, getHandle(), inHandle, NULL);
+        }
+        return kOfxStatFailed;
+      }
+      
+      // do nothing
+      int Instance::getDimension(const std::string &name) const
+      {
+        if(name == kOfxInteractPropPixelScale){
+          return 2;
+        }
+        else if(name == kOfxInteractPropBackgroundColour){
+          return 3;
+        }
+        else if(name == kOfxInteractPropSuggestedColour
+                ){
+          return 3;
+        }
+#ifdef kOfxInteractPropViewportSize // removed in OFX 1.4
+        else if(name == kOfxInteractPropViewportSize){
+          return 2;
+        }
+#endif
+        else
+          throw Property::Exception(kOfxStatErrValue);
+      }
+        
+      // do nothing function
+      void Instance::reset(const std::string &/*name*/)
+      {
+        // no-op
+      }
+
+      double Instance::getDoubleProperty(const std::string &name, int index) const
+      {   
+        if(name == kOfxInteractPropPixelScale){
+          if(index>=2) throw Property::Exception(kOfxStatErrBadIndex);
+          double first[2];
+          getPixelScale(first[0],first[1]);
+          return first[index];
+        }
+        else if(name == kOfxInteractPropBackgroundColour){
+          if(index>=3) throw Property::Exception(kOfxStatErrBadIndex);
+          double first[3];
+          getBackgroundColour(first[0],first[1],first[2]);
+          return first[index];
+        }
+        else if(name == kOfxInteractPropSuggestedColour
+                ){
+          if(index>=3) throw Property::Exception(kOfxStatErrBadIndex);
+          double first[3];
+          bool stat = getSuggestedColour(first[0],first[1],first[2]);
+          if (!stat) throw Property::Exception(kOfxStatReplyDefault);
+          return first[index];
+        }
+#ifdef kOfxInteractPropViewportSize // removed in OFX 1.4
+        else if(name == kOfxInteractPropViewportSize){
+          if(index>=2) throw Property::Exception(kOfxStatErrBadIndex);
+          double first[2];
+          getViewportSize(first[0],first[1]);
+          return first[index];
+        }
+#endif
+        else
+          throw Property::Exception(kOfxStatErrUnknown);
+      }
+
+      void Instance::getDoublePropertyN(const std::string &name, double *first, int n) const
+      {
+        if(name == kOfxInteractPropPixelScale){
+          if(n>2) throw Property::Exception(kOfxStatErrBadIndex);
+          getPixelScale(first[0],first[1]);
+        }
+        else if(name == kOfxInteractPropBackgroundColour){
+          if(n>3) throw Property::Exception(kOfxStatErrBadIndex);
+          getBackgroundColour(first[0],first[1],first[2]);
+        }
+        else if(name == kOfxInteractPropSuggestedColour
+                ){
+          if(n>3) throw Property::Exception(kOfxStatErrBadIndex);
+          bool stat = getSuggestedColour(first[0],first[1],first[2]);
+          if (!stat) throw Property::Exception(kOfxStatReplyDefault);
+        }
+#ifdef kOfxInteractPropViewportSize // removed in OFX 1.4
+        else if(name == kOfxInteractPropViewportSize){
+          if(n>2) throw Property::Exception(kOfxStatErrBadIndex);
+          getViewportSize(first[0],first[1]);
+        }
+#endif
+        else
+          throw Property::Exception(kOfxStatErrUnknown);
+      }
+
+      void Instance::getSlaveToParam(std::vector<std::string>& params) const
+      {        
+        int nSlaveParams = _properties.getDimension(kOfxInteractPropSlaveToParam);
+                    
+        for (int i=0; i<nSlaveParams; i++) {
+          std::string param = _properties.getStringProperty(kOfxInteractPropSlaveToParam, i);
+          params.push_back(param);
+        }
+      }    
+      
+      /// initialise the argument properties
+      void Instance::initArgProp(OfxTime time, 
+                                 const OfxPointD &renderScale)
+      {
+        double pixelScale[2];
+        getPixelScale(pixelScale[0], pixelScale[1]);  
+        _argProperties.setDoublePropertyN(kOfxInteractPropPixelScale, pixelScale, 2);
+        _argProperties.setPointerProperty(kOfxPropEffectInstance, _effectInstance);
+        _argProperties.setPointerProperty(kOfxPropInstanceData, _properties.getPointerProperty(kOfxPropInstanceData));
+        _argProperties.setDoubleProperty(kOfxPropTime,time);
+        _argProperties.setDoublePropertyN(kOfxImageEffectPropRenderScale, &renderScale.x, 2);
+      }
+               
+      void Instance::setPenArgProps(const OfxPointD &penPos,
+                                    const OfxPointI &penPosViewport,
+                                    double  pressure)
+      {
+        _argProperties.setDoublePropertyN(kOfxInteractPropPenPosition, &penPos.x, 2);
+        _argProperties.setIntPropertyN(kOfxInteractPropPenViewportPosition, &penPosViewport.x, 2); // new in OFX 1.2
+        _argProperties.setDoubleProperty(kOfxInteractPropPenPressure, pressure);
+      }
+
+      void Instance::setKeyArgProps(int     key,
+                                    char*   keyString)
+      {
+        _argProperties.setIntProperty(kOfxPropKeySym,key);
+        _argProperties.setStringProperty(kOfxPropKeyString,keyString);
+      }
+
+      OfxStatus Instance::createInstanceAction()
+      {        
+        OfxStatus stat = callEntry(kOfxActionCreateInstance, NULL);
+        if(stat == kOfxStatOK || stat == kOfxStatReplyDefault) {
+          _state = eCreated;
+        }
+        else {
+          _state = eFailed;
+        }
+        return stat;
+      }
+
+      OfxStatus Instance::drawAction(OfxTime time,  
+                                     const OfxPointD &renderScale)
+      {        
+        initArgProp(time, renderScale);
+        return callEntry(kOfxInteractActionDraw, &_argProperties);
+      }
+
+      OfxStatus Instance::penMotionAction(OfxTime time, 
+                                          const OfxPointD &renderScale,
+                                          const OfxPointD &penPos,
+                                          const OfxPointI &penPosViewport,
+                                          double  pressure)
+      {
+        initArgProp(time, renderScale);
+        setPenArgProps(penPos, penPosViewport, pressure);
+        return callEntry(kOfxInteractActionPenMotion,&_argProperties);
+      }
+
+      OfxStatus Instance::penUpAction(OfxTime time, 
+                                      const OfxPointD &renderScale,
+                                      const OfxPointD &penPos,
+                                      const OfxPointI &penPosViewport,
+                                      double pressure)
+      {
+        initArgProp(time, renderScale);
+        setPenArgProps(penPos, penPosViewport, pressure);
+        return callEntry(kOfxInteractActionPenUp,&_argProperties);
+      }
+
+      OfxStatus Instance::penDownAction(OfxTime time, 
+                                        const OfxPointD &renderScale,
+                                        const OfxPointD &penPos,
+                                        const OfxPointI &penPosViewport,
+                                        double pressure)
+      {
+        initArgProp(time, renderScale);
+        setPenArgProps(penPos, penPosViewport, pressure);
+        return callEntry(kOfxInteractActionPenDown,&_argProperties);
+      }
+
+      OfxStatus Instance::keyDownAction(OfxTime time, 
+                                        const OfxPointD &renderScale,
+                                        int     key,
+                                        char*   keyString)
+      {
+        initArgProp(time, renderScale);
+        setKeyArgProps(key, keyString);
+        return callEntry(kOfxInteractActionKeyDown,&_argProperties);
+      }
+
+      OfxStatus Instance::keyUpAction(OfxTime time, 
+                                      const OfxPointD &renderScale,
+                                      int     key,
+                                      char*   keyString)
+      {
+        initArgProp(time, renderScale);
+        setKeyArgProps(key, keyString);
+        return callEntry(kOfxInteractActionKeyUp,&_argProperties);
+      }
+
+      OfxStatus Instance::keyRepeatAction(OfxTime time,
+                                          const OfxPointD &renderScale,
+                                          int     key,
+                                          char*   keyString)
+      {
+        initArgProp(time, renderScale);
+        setKeyArgProps(key, keyString);
+        return callEntry(kOfxInteractActionKeyRepeat,&_argProperties);
+      }
+      
+      OfxStatus Instance::gainFocusAction(OfxTime time,
+                                          const OfxPointD &renderScale)
+      {
+        initArgProp(time, renderScale);
+        return callEntry(kOfxInteractActionGainFocus,&_argProperties);
+      }
+
+      OfxStatus Instance::loseFocusAction(OfxTime  time,
+                                          const OfxPointD &renderScale)
+      {
+        initArgProp(time, renderScale);
+        return callEntry(kOfxInteractActionLoseFocus,&_argProperties);
+      }
+
+      ////////////////////////////////////////////////////////////////////////////////
+      ////////////////////////////////////////////////////////////////////////////////
+      ////////////////////////////////////////////////////////////////////////////////
+      // Interact suite functions
+
+      static OfxStatus interactSwapBuffers(OfxInteractHandle handle)
+      {
+        try {
+        Interact::Instance *interactInstance = reinterpret_cast<Interact::Instance*>(handle);
+        if(interactInstance)
+          return interactInstance->swapBuffers();
+        else
+          return kOfxStatErrBadHandle;
+        } catch (...) {
+          return kOfxStatFailed;
+        }
+      }
+      
+      static OfxStatus interactRedraw(OfxInteractHandle handle)
+      {
+        try {
+        Interact::Instance *interactInstance = reinterpret_cast<Interact::Instance*>(handle);
+        if(interactInstance)
+          return interactInstance->redraw();
+        else
+          return kOfxStatErrBadHandle;
+        } catch (...) {
+          return kOfxStatFailed;
+        }
+      }
+      
+      static OfxStatus interactGetPropertySet(OfxInteractHandle handle, OfxPropertySetHandle *property)
+      {
+        try {
+        Interact::Base *interact = reinterpret_cast<Interact::Base*>(handle);
+        if (!property) {
+          return kOfxStatErrBadHandle;
+        }
+
+        if (interact) {
+          *property = interact->getPropHandle();
+
+          return kOfxStatOK;
+        }
+        *property = NULL;
+
+        return kOfxStatErrBadHandle;
+        } catch (...) {
+          return kOfxStatFailed;
+        }
+      }
+      
+      /// the interact suite
+      static const OfxInteractSuiteV1 gSuite = {
+        interactSwapBuffers,
+        interactRedraw,
+        interactGetPropertySet
+      };
+
+      /// function to get the sutie
+      const void *GetSuite(int version) {
+        if(version == 1)
+          return (void *) &gSuite;
+        return NULL;
+      }
+
+
+    } // Interact
+
+  } // Host
+
+} // OFX