cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/faust/gui/JSONUIDecoder.h

@@ -0,0 +1,589 @@
+/************************** BEGIN JSONUIDecoder.h **************************
+ FAUST Architecture File
+ Copyright (C) 2003-2022 GRAME, Centre National de Creation Musicale
+ ---------------------------------------------------------------------
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+ 
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+ 
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ 
+ EXCEPTION : As a special exception, you may create a larger work
+ that contains this FAUST architecture section and distribute
+ that work under terms of your choice, so long as this FAUST
+ architecture section is not modified.
+ *************************************************************************/
+
+#ifndef __JSONUIDecoder__
+#define __JSONUIDecoder__
+
+#include <vector>
+#include <map>
+#include <utility>
+#include <cstdlib>
+#include <sstream>
+#include <functional>
+
+#include "faust/gui/CGlue.h"
+#include "faust/gui/meta.h"
+#include "faust/gui/SimpleParser.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#define snprintf _snprintf
+#define STRDUP _strdup
+#else
+#define STRDUP strdup
+#endif
+
+//------------------------------------------------------------------------------------------
+//  Decode a dsp JSON description and implement 'buildUserInterface' and 'metadata' methods
+//------------------------------------------------------------------------------------------
+
+#define REAL_UI(ui_interface) reinterpret_cast<UIReal<REAL>*>(ui_interface)
+#define REAL_ADR(index)      reinterpret_cast<REAL*>(&memory_block[index])
+#define REAL_EXT_ADR(index)  reinterpret_cast<FAUSTFLOAT*>(&memory_block[index])
+#define SOUNDFILE_ADR(index) reinterpret_cast<Soundfile**>(&memory_block[index])
+
+typedef std::function<void(FAUSTFLOAT)> ReflectFunction;
+typedef std::function<FAUSTFLOAT()> ModifyFunction;
+
+struct FAUST_API ExtZoneParam {
+
+    virtual void reflectZone() = 0;
+    virtual void modifyZone() = 0;
+    
+    virtual void setReflectZoneFun(ReflectFunction reflect) = 0;
+    virtual void setModifyZoneFun(ModifyFunction modify) = 0;
+    
+    virtual ~ExtZoneParam()
+    {}
+    
+};
+
+// Templated decoder
+
+struct FAUST_API JSONUIDecoderBase
+{
+    virtual ~JSONUIDecoderBase()
+    {}
+    
+    virtual void metadata(Meta* m) = 0;
+    virtual void metadata(MetaGlue* glue) = 0;
+    virtual int getDSPSize() = 0;
+    virtual std::string getName() = 0;
+    virtual std::string getLibVersion() = 0;
+    virtual std::string getCompileOptions() = 0;
+    virtual std::vector<std::string> getLibraryList() = 0;
+    virtual std::vector<std::string> getIncludePathnames() = 0;
+    virtual int getNumInputs() = 0;
+    virtual int getNumOutputs() = 0;
+    virtual int getSampleRate(char* memory_block) = 0;
+    virtual void setReflectZoneFun(int index, ReflectFunction fun) = 0;
+    virtual void setModifyZoneFun(int index, ModifyFunction fun) = 0;
+    virtual void setupDSPProxy(UI* ui_interface, char* memory_block) = 0;
+    virtual bool hasDSPProxy() = 0;
+    virtual std::vector<ExtZoneParam*>& getInputControls() = 0;
+    virtual std::vector<ExtZoneParam*>& getOutputControls() = 0;
+    virtual void resetUserInterface() = 0;
+    virtual void resetUserInterface(char* memory_block, Soundfile* defaultsound = nullptr) = 0;
+    virtual void buildUserInterface(UI* ui_interface) = 0;
+    virtual void buildUserInterface(UI* ui_interface, char* memory_block) = 0;
+    virtual void buildUserInterface(UIGlue* ui_interface, char* memory_block) = 0;
+    virtual bool hasCompileOption(const std::string& option) = 0;
+};
+
+template <typename REAL>
+struct FAUST_API JSONUIDecoderReal : public JSONUIDecoderBase {
+    
+    struct ZoneParam : public ExtZoneParam {
+        
+        FAUSTFLOAT fZone;
+        ReflectFunction fReflect;
+        ModifyFunction fModify;
+        
+    #if defined(TARGET_OS_IPHONE) || defined(WIN32)
+        ZoneParam(ReflectFunction reflect = nullptr, ModifyFunction modify = nullptr)
+        :fReflect(reflect), fModify(modify)
+        {}
+        void reflectZone() { if (fReflect) fReflect(fZone); }
+        void modifyZone() { if (fModify) fZone = fModify(); }
+    #else
+        ZoneParam(ReflectFunction reflect = [](FAUSTFLOAT value) {}, ModifyFunction modify = []() { return FAUSTFLOAT(-1); })
+        :fReflect(reflect), fModify(modify)
+        {}
+        void reflectZone() { fReflect(fZone); }
+        void modifyZone() { fZone = fModify(); }
+    #endif
+        
+        void setReflectZoneFun(ReflectFunction reflect) { fReflect = reflect; }
+        void setModifyZoneFun(ModifyFunction modify) { fModify = modify; }
+        
+    };
+    
+    typedef std::vector<ExtZoneParam*> controlMap;
+  
+    std::string fName;
+    std::string fFileName;
+    std::string fJSON;
+    std::string fVersion;
+    std::string fCompileOptions;
+    
+    std::map<std::string, std::string> fMetadata;
+    std::vector<itemInfo> fUiItems;
+    
+    std::vector<std::string> fLibraryList;
+    std::vector<std::string> fIncludePathnames;
+    
+    int fNumInputs, fNumOutputs, fSRIndex;
+    int fDSPSize;
+    bool fDSPProxy;
+    
+    controlMap fPathInputTable;     // [path, ZoneParam]
+    controlMap fPathOutputTable;    // [path, ZoneParam]
+    
+    bool startWith(const std::string& str, const std::string& prefix)
+    {
+        return (str.substr(0, prefix.size()) == prefix);
+    }
+
+    bool isInput(const std::string& type)
+    {
+        return (type == "vslider" || type == "hslider" || type == "nentry" || type == "button" || type == "checkbox");
+    }
+    bool isOutput(const std::string& type) { return (type == "hbargraph" || type == "vbargraph"); }
+    bool isSoundfile(const std::string& type) { return (type == "soundfile"); }
+    
+    std::string getString(std::map<std::string, std::pair<std::string, double> >& map, const std::string& key)
+    {
+        return (map.find(key) != map.end()) ? map[key].first : "";
+    }
+    
+    int getInt(std::map<std::string, std::pair<std::string, double> >& map, const std::string& key)
+    {
+        return (map.find(key) != map.end()) ? int(map[key].second) : -1;
+    }
+    
+    void setReflectZoneFun(int index, ReflectFunction fun)
+    {
+        fPathInputTable[index]->setReflectZoneFun(fun);
+    }
+    
+    void setModifyZoneFun(int index, ModifyFunction fun)
+    {
+        fPathOutputTable[index]->setModifyZoneFun(fun);
+    }
+
+    JSONUIDecoderReal(const std::string& json)
+    {
+        fJSON = json;
+        const char* p = fJSON.c_str();
+        std::map<std::string, std::pair<std::string, double> > meta_data1;
+        std::map<std::string, std::vector<std::string> > meta_data2;
+        parseJson(p, meta_data1, fMetadata, meta_data2, fUiItems);
+        
+        // meta_data1 contains <name : val>, <inputs : val>, <ouputs : val> pairs etc...
+        fName = getString(meta_data1, "name");
+        fFileName = getString(meta_data1, "filename");
+        fVersion = getString(meta_data1, "version");
+        fCompileOptions = getString(meta_data1, "compile_options");
+        
+        if (meta_data2.find("library_list") != meta_data2.end()) {
+            fLibraryList = meta_data2["library_list"];
+        } else {
+            // 'library_list' is coded as successive 'library_pathN' metadata
+            for (const auto& it : fMetadata) {
+                if (startWith(it.first, "library_path")) {
+                    fLibraryList.push_back(it.second);
+                }
+            }
+        }
+        if (meta_data2.find("include_pathnames") != meta_data2.end()) {
+            fIncludePathnames = meta_data2["include_pathnames"];
+        }
+        
+        fDSPSize = getInt(meta_data1, "size");
+        fNumInputs = getInt(meta_data1, "inputs");
+        fNumOutputs = getInt(meta_data1, "outputs");
+        fSRIndex = getInt(meta_data1, "sr_index");
+        fDSPProxy = false;
+        
+        // Prepare the fPathTable and init zone
+        for (const auto& it : fUiItems) {
+            std::string type = it.type;
+            // Meta data declaration for input items
+            if (isInput(type)) {
+                ZoneParam* param = new ZoneParam();
+                fPathInputTable.push_back(param);
+                param->fZone = it.init;
+            }
+            // Meta data declaration for output items
+            else if (isOutput(type)) {
+                ZoneParam* param = new ZoneParam();
+                fPathOutputTable.push_back(param);
+                param->fZone = REAL(0);
+            }
+        }
+    }
+    
+    virtual ~JSONUIDecoderReal()
+    {
+        for (const auto& it : fPathInputTable) {
+            delete it;
+        }
+        for (const auto& it : fPathOutputTable) {
+            delete it;
+        }
+    }
+    
+    void metadata(Meta* m)
+    {
+        for (const auto& it : fMetadata) {
+            m->declare(it.first.c_str(), it.second.c_str());
+        }
+    }
+    
+    void metadata(MetaGlue* m)
+    {
+        for (const auto& it : fMetadata) {
+            m->declare(m->metaInterface, it.first.c_str(), it.second.c_str());
+        }
+    }
+    
+    void resetUserInterface()
+    {
+        int item = 0;
+        for (const auto& it : fUiItems) {
+            if (isInput(it.type)) {
+                static_cast<ZoneParam*>(fPathInputTable[item++])->fZone = it.init;
+            }
+        }
+    }
+    
+    void resetUserInterface(char* memory_block, Soundfile* defaultsound = nullptr)
+    {
+        for (const auto& it : fUiItems) {
+            int index = it.index;
+            if (isInput(it.type)) {
+                *REAL_ADR(index) = it.init;
+            } else if (isSoundfile(it.type)) {
+                if (*SOUNDFILE_ADR(index) == nullptr) {
+                    *SOUNDFILE_ADR(index) = defaultsound;
+                }
+            }
+        }
+    }
+    
+    int getSampleRate(char* memory_block)
+    {
+        return *reinterpret_cast<int*>(&memory_block[fSRIndex]);
+    }
+    
+    void setupDSPProxy(UI* ui_interface, char* memory_block)
+    {
+        if (!fDSPProxy) {
+            fDSPProxy = true;
+            int countIn = 0;
+            int countOut = 0;
+            for (const auto& it : fUiItems) {
+                std::string type = it.type;
+                int index = it.index;
+                if (isInput(type)) {
+                    fPathInputTable[countIn++]->setReflectZoneFun([=](FAUSTFLOAT value) { *REAL_ADR(index) = REAL(value); });
+                } else if (isOutput(type)) {
+                    fPathOutputTable[countOut++]->setModifyZoneFun([=]() { return FAUSTFLOAT(*REAL_ADR(index)); });
+                }
+            }
+        }
+        
+        // Setup soundfile in any case
+        for (const auto& it : fUiItems) {
+            if (isSoundfile(it.type)) {
+                ui_interface->addSoundfile(it.label.c_str(), it.url.c_str(), SOUNDFILE_ADR(it.index));
+            }
+        }
+    }
+    
+    bool hasDSPProxy() { return fDSPProxy; }
+  
+    void buildUserInterface(UI* ui_interface)
+    {
+        // MANDATORY: to be sure floats or double are correctly parsed
+        char* tmp_local = setlocale(LC_ALL, nullptr);
+        if (tmp_local != NULL) {
+            tmp_local = STRDUP(tmp_local);
+        }
+        setlocale(LC_ALL, "C");
+        
+        int countIn = 0;
+        int countOut = 0;
+        int countSound = 0;
+        
+        for (const auto& it : fUiItems) {
+            
+            std::string type = it.type;
+            REAL init = REAL(it.init);
+            REAL min = REAL(it.fmin);
+            REAL max = REAL(it.fmax);
+            REAL step = REAL(it.step);
+            
+            // Meta data declaration for input items
+            if (isInput(type)) {
+                for (size_t i = 0; i < it.meta.size(); i++) {
+                    ui_interface->declare(&static_cast<ZoneParam*>(fPathInputTable[countIn])->fZone, it.meta[i].first.c_str(), it.meta[i].second.c_str());
+                }
+            }
+            // Meta data declaration for output items
+            else if (isOutput(type)) {
+                for (size_t i = 0; i < it.meta.size(); i++) {
+                    ui_interface->declare(&static_cast<ZoneParam*>(fPathOutputTable[countOut])->fZone, it.meta[i].first.c_str(), it.meta[i].second.c_str());
+                }
+            }
+            // Meta data declaration for group opening or closing
+            else {
+                for (size_t i = 0; i < it.meta.size(); i++) {
+                    ui_interface->declare(0, it.meta[i].first.c_str(), it.meta[i].second.c_str());
+                }
+            }
+            
+            if (type == "hgroup") {
+                ui_interface->openHorizontalBox(it.label.c_str());
+            } else if (type == "vgroup") {
+                ui_interface->openVerticalBox(it.label.c_str());
+            } else if (type == "tgroup") {
+                ui_interface->openTabBox(it.label.c_str());
+            } else if (type == "vslider") {
+                ui_interface->addVerticalSlider(it.label.c_str(), &static_cast<ZoneParam*>(fPathInputTable[countIn])->fZone, init, min, max, step);
+            } else if (type == "hslider") {
+                ui_interface->addHorizontalSlider(it.label.c_str(), &static_cast<ZoneParam*>(fPathInputTable[countIn])->fZone, init, min, max, step);
+            } else if (type == "checkbox") {
+                ui_interface->addCheckButton(it.label.c_str(), &static_cast<ZoneParam*>(fPathInputTable[countIn])->fZone);
+            } else if (type == "soundfile") {
+                // Nothing
+            } else if (type == "hbargraph") {
+                ui_interface->addHorizontalBargraph(it.label.c_str(), &static_cast<ZoneParam*>(fPathOutputTable[countOut])->fZone, min, max);
+            } else if (type == "vbargraph") {
+                ui_interface->addVerticalBargraph(it.label.c_str(), &static_cast<ZoneParam*>(fPathOutputTable[countOut])->fZone, min, max);
+            } else if (type == "nentry") {
+                ui_interface->addNumEntry(it.label.c_str(), &static_cast<ZoneParam*>(fPathInputTable[countIn])->fZone, init, min, max, step);
+            } else if (type == "button") {
+                ui_interface->addButton(it.label.c_str(), &static_cast<ZoneParam*>(fPathInputTable[countIn])->fZone);
+            } else if (type == "close") {
+                ui_interface->closeBox();
+            }
+            
+            if (isInput(type)) {
+                countIn++;
+            } else if (isOutput(type)) {
+                countOut++;
+            } else if (isSoundfile(type)) {
+                countSound++;
+            }
+        }
+        
+        if (tmp_local != NULL) {
+            setlocale(LC_ALL, tmp_local);
+            free(tmp_local);
+        }
+    }
+    
+    void buildUserInterface(UI* ui_interface, char* memory_block)
+    {
+        // MANDATORY: to be sure floats or double are correctly parsed
+        char* tmp_local = setlocale(LC_ALL, nullptr);
+        if (tmp_local != NULL) {
+            tmp_local = STRDUP(tmp_local);
+        }
+        setlocale(LC_ALL, "C");
+        
+        for (const auto& it : fUiItems) {
+            
+            std::string type = it.type;
+            int index = it.index;
+            REAL init = REAL(it.init);
+            REAL min = REAL(it.fmin);
+            REAL max = REAL(it.fmax);
+            REAL step = REAL(it.step);
+            
+            // Meta data declaration for input items
+            if (isInput(type)) {
+                for (size_t i = 0; i < it.meta.size(); i++) {
+                    REAL_UI(ui_interface)->declare(REAL_ADR(index), it.meta[i].first.c_str(), it.meta[i].second.c_str());
+                }
+            }
+            // Meta data declaration for output items
+            else if (isOutput(type)) {
+                for (size_t i = 0; i < it.meta.size(); i++) {
+                    REAL_UI(ui_interface)->declare(REAL_ADR(index), it.meta[i].first.c_str(), it.meta[i].second.c_str());
+                }
+            }
+            // Meta data declaration for group opening or closing
+            else {
+                for (size_t i = 0; i < it.meta.size(); i++) {
+                    REAL_UI(ui_interface)->declare(0, it.meta[i].first.c_str(), it.meta[i].second.c_str());
+                }
+            }
+            
+            if (type == "hgroup") {
+                REAL_UI(ui_interface)->openHorizontalBox(it.label.c_str());
+            } else if (type == "vgroup") {
+                REAL_UI(ui_interface)->openVerticalBox(it.label.c_str());
+            } else if (type == "tgroup") {
+                REAL_UI(ui_interface)->openTabBox(it.label.c_str());
+            } else if (type == "vslider") {
+                REAL_UI(ui_interface)->addVerticalSlider(it.label.c_str(), REAL_ADR(index), init, min, max, step);
+            } else if (type == "hslider") {
+                REAL_UI(ui_interface)->addHorizontalSlider(it.label.c_str(), REAL_ADR(index), init, min, max, step);
+            } else if (type == "checkbox") {
+                REAL_UI(ui_interface)->addCheckButton(it.label.c_str(), REAL_ADR(index));
+            } else if (type == "soundfile") {
+                REAL_UI(ui_interface)->addSoundfile(it.label.c_str(), it.url.c_str(), SOUNDFILE_ADR(index));
+            } else if (type == "hbargraph") {
+                REAL_UI(ui_interface)->addHorizontalBargraph(it.label.c_str(), REAL_ADR(index), min, max);
+            } else if (type == "vbargraph") {
+                REAL_UI(ui_interface)->addVerticalBargraph(it.label.c_str(), REAL_ADR(index), min, max);
+            } else if (type == "nentry") {
+                REAL_UI(ui_interface)->addNumEntry(it.label.c_str(), REAL_ADR(index), init, min, max, step);
+            } else if (type == "button") {
+                REAL_UI(ui_interface)->addButton(it.label.c_str(), REAL_ADR(index));
+            } else if (type == "close") {
+                REAL_UI(ui_interface)->closeBox();
+            }
+        }
+        
+        if (tmp_local != NULL) {
+            setlocale(LC_ALL, tmp_local);
+            free(tmp_local);
+        }
+    }
+    
+    void buildUserInterface(UIGlue* ui_interface, char* memory_block)
+    {
+        // MANDATORY: to be sure floats or double are correctly parsed
+        char* tmp_local = setlocale(LC_ALL, nullptr);
+        if (tmp_local != NULL) {
+            tmp_local = STRDUP(tmp_local);
+        }
+        setlocale(LC_ALL, "C");
+        
+        for (const auto& it : fUiItems) {
+            
+            std::string type = it.type;
+            int index = it.index;
+            REAL init = REAL(it.init);
+            REAL min = REAL(it.fmin);
+            REAL max = REAL(it.fmax);
+            REAL step = REAL(it.step);
+            
+            // Meta data declaration for input items
+            if (isInput(type)) {
+                for (size_t i = 0; i < it.meta.size(); i++) {
+                    ui_interface->declare(ui_interface->uiInterface, REAL_EXT_ADR(index), it.meta[i].first.c_str(), it.meta[i].second.c_str());
+                }
+            }
+            // Meta data declaration for output items
+            else if (isOutput(type)) {
+                for (size_t i = 0; i < it.meta.size(); i++) {
+                    ui_interface->declare(ui_interface->uiInterface, REAL_EXT_ADR(index), it.meta[i].first.c_str(), it.meta[i].second.c_str());
+                }
+            }
+            // Meta data declaration for group opening or closing
+            else {
+                for (size_t i = 0; i < it.meta.size(); i++) {
+                    ui_interface->declare(ui_interface->uiInterface, 0, it.meta[i].first.c_str(), it.meta[i].second.c_str());
+                }
+            }
+            
+            if (type == "hgroup") {
+                ui_interface->openHorizontalBox(ui_interface->uiInterface, it.label.c_str());
+            } else if (type == "vgroup") {
+                ui_interface->openVerticalBox(ui_interface->uiInterface, it.label.c_str());
+            } else if (type == "tgroup") {
+                ui_interface->openTabBox(ui_interface->uiInterface, it.label.c_str());
+            } else if (type == "vslider") {
+                ui_interface->addVerticalSlider(ui_interface->uiInterface, it.label.c_str(), REAL_EXT_ADR(index), init, min, max, step);
+            } else if (type == "hslider") {
+                ui_interface->addHorizontalSlider(ui_interface->uiInterface, it.label.c_str(), REAL_EXT_ADR(index), init, min, max, step);
+            } else if (type == "checkbox") {
+                ui_interface->addCheckButton(ui_interface->uiInterface, it.label.c_str(), REAL_EXT_ADR(index));
+            } else if (type == "soundfile") {
+                ui_interface->addSoundfile(ui_interface->uiInterface, it.label.c_str(), it.url.c_str(), SOUNDFILE_ADR(index));
+            } else if (type == "hbargraph") {
+                ui_interface->addHorizontalBargraph(ui_interface->uiInterface, it.label.c_str(), REAL_EXT_ADR(index), min, max);
+            } else if (type == "vbargraph") {
+                ui_interface->addVerticalBargraph(ui_interface->uiInterface, it.label.c_str(), REAL_EXT_ADR(index), min, max);
+            } else if (type == "nentry") {
+                ui_interface->addNumEntry(ui_interface->uiInterface, it.label.c_str(), REAL_EXT_ADR(index), init, min, max, step);
+            } else if (type == "button") {
+                ui_interface->addButton(ui_interface->uiInterface, it.label.c_str(), REAL_EXT_ADR(index));
+            } else if (type == "close") {
+                ui_interface->closeBox(ui_interface->uiInterface);
+            }
+        }
+        
+        if (tmp_local != NULL) {
+            setlocale(LC_ALL, tmp_local);
+            free(tmp_local);
+        }
+    }
+    
+    bool hasCompileOption(const std::string& option)
+    {
+        std::istringstream iss(fCompileOptions);
+        std::string token;
+        while (std::getline(iss, token, ' ')) {
+            if (token == option) return true;
+        }
+        return false;
+    }
+    
+    int getDSPSize() { return fDSPSize; }
+    std::string getName() { return fName; }
+    std::string getLibVersion() { return fVersion; }
+    std::string getCompileOptions() { return fCompileOptions; }
+    std::vector<std::string> getLibraryList() { return fLibraryList; }
+    std::vector<std::string> getIncludePathnames() { return fIncludePathnames; }
+    int getNumInputs() { return fNumInputs; }
+    int getNumOutputs() { return fNumOutputs; }
+    
+    std::vector<ExtZoneParam*>& getInputControls()
+    {
+        return fPathInputTable;
+    }
+    std::vector<ExtZoneParam*>& getOutputControls()
+    {
+        return fPathOutputTable;
+    }
+    
+};
+
+// FAUSTFLOAT templated decoder
+
+struct FAUST_API JSONUIDecoder : public JSONUIDecoderReal<FAUSTFLOAT>
+{
+    JSONUIDecoder(const std::string& json):JSONUIDecoderReal<FAUSTFLOAT>(json)
+    {}
+};
+
+// Generic factory
+
+static JSONUIDecoderBase* createJSONUIDecoder(const std::string& json)
+{
+    JSONUIDecoder decoder(json);
+    if (decoder.hasCompileOption("-double")) {
+        return new JSONUIDecoderReal<double>(json);
+    } else {
+        return new JSONUIDecoderReal<float>(json);
+    }
+}
+
+#endif
+/**************************  END  JSONUIDecoder.h **************************/