cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

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

@@ -0,0 +1,163 @@
+/************************** BEGIN JuceOSCUI.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 __juce_osc__
+#define __juce_osc__
+ 
+#include "../JuceLibraryCode/JuceHeader.h"
+
+#include "faust/gui/GUI.h"
+#include "faust/gui/APIUI.h"
+
+class oscItem : public uiItem {
+    
+    protected:
+        
+        juce::OSCSender* fSender;
+        juce::String fPath;
+        
+    public:
+        
+        oscItem(juce::OSCSender* sender, GUI* ui, const juce::String& path, FAUSTFLOAT* zone)
+        :uiItem(ui, zone), fSender(sender), fPath(path) {}
+        virtual ~oscItem()
+        {}
+        
+        virtual void reflectZone()
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+            fSender->send(fPath, float(v));
+        }
+    
+};
+
+class JuceOSCUI : private juce::OSCReceiver, private juce::OSCReceiver::Listener<juce::OSCReceiver::RealtimeCallback>, public GUI {
+    
+    private:
+        
+        juce::OSCSender fSender;
+        juce::String fIP;
+        int fInputPort, fOutputPort;
+        APIUI fAPIUI;
+        juce::Array<oscItem*> fOSCItems;  // Pointers are kept and desallocated by the GUI class
+        
+    public:
+        
+        JuceOSCUI(const std::string& ip, int in_port, int out_port)
+        :fIP(ip), fInputPort(in_port), fOutputPort(out_port)
+        {}
+        
+        virtual ~JuceOSCUI()
+        {}
+        
+        void oscMessageReceived(const juce::OSCMessage& message) override
+        {
+            juce::String address = message.getAddressPattern().toString();
+            
+            for (int i = 0; i < message.size(); ++i) {
+                if (message[i].isFloat32()) {
+                    fAPIUI.setParamValue(address.toStdString().c_str(), FAUSTFLOAT(message[i].getFloat32()));
+                    // "get" message with correct address
+                } else if (message[i].isString()
+                           && message[i].getString().equalsIgnoreCase("get")
+                           && juce::String(fAPIUI.getParamAddress(0)).startsWith(address)) {
+                    for (int p = 0; p < fAPIUI.getParamsCount(); ++p) {
+                        fSender.send(fAPIUI.getParamAddress(p), float(fAPIUI.getParamValue(p)), float(fAPIUI.getParamMin(p)), float(fAPIUI.getParamMax(p)));
+                    }
+                    // "hello" message
+                } else if (message[i].isString()
+                           && address.equalsIgnoreCase("/*")
+                           && message[i].getString().equalsIgnoreCase("hello")) {
+                    juce::String path = fAPIUI.getParamAddress(0);
+                    int pos1 = path.indexOfChar('/');
+                    int pos2 = path.indexOfChar(pos1 + 1, '/');
+                    fSender.send(path.substring(pos1, pos2), fIP, fInputPort, fOutputPort);
+                }
+            }
+        }
+        
+        bool run() override
+        {
+            // Keep all zones for update when OSC messages are received
+            if (fOSCItems.size() == 0) {
+                for (int p = 0; p < fAPIUI.getParamsCount(); ++p) {
+                    fOSCItems.add(new oscItem(&fSender, this, fAPIUI.getParamAddress(p), fAPIUI.getParamZone(p)));
+                }
+            }
+            
+            if (!fSender.connect(fIP, fOutputPort)) {
+                std::cerr << "Error: could not connect to UDP port " << fInputPort << std::endl;
+                return false;
+            }
+            
+            if (!connect(fInputPort)) {
+                std::cerr << "Error: could not connect to UDP port " << fOutputPort << std::endl;
+                return false;
+            }
+            addListener(this);
+            return true;
+        }
+        
+        void stop() override
+        {
+            fSender.disconnect();
+            disconnect();
+            removeListener(this);
+        }
+        
+        // -- widget's layouts
+        
+        void openTabBox(const char* label) override { fAPIUI.openTabBox(label); }
+        void openHorizontalBox(const char* label) override { fAPIUI.openHorizontalBox(label); }
+        void openVerticalBox(const char* label) override { fAPIUI.openVerticalBox(label); }
+        void closeBox() override { fAPIUI.closeBox(); }
+        
+        // -- active widgets
+        
+        void addButton(const char* label, FAUSTFLOAT* zone) override { fAPIUI.addButton(label, zone); }
+        void addCheckButton(const char* label, FAUSTFLOAT* zone) override { fAPIUI.addCheckButton(label, zone); }
+        void addVerticalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) override
+        { fAPIUI.addVerticalSlider(label, zone, init, min, max, step); }
+        void addHorizontalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) override
+        { fAPIUI.addHorizontalSlider(label, zone, init, min, max, step); }
+        void addNumEntry(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) override
+        { fAPIUI.addNumEntry(label, zone, init, min, max, step); }
+        
+        // -- passive widgets
+        
+        void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) override
+        { fAPIUI.addHorizontalBargraph(label, zone, min, max); }
+        void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) override
+        { fAPIUI.addVerticalBargraph(label, zone, min, max); }
+        
+        // -- metadata declarations
+        
+        void declare(FAUSTFLOAT* zone, const char* key, const char* val) override { fAPIUI.declare(zone, key, val); }
+    
+};
+
+#endif // __juce_osc__
+
+/**************************  END  JuceOSCUI.h **************************/

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

@@ -0,0 +1,158 @@
+/************************** BEGIN JuceParameterUI.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 JuceParameterUI_H
+#define JuceParameterUI_H
+
+#include "../JuceLibraryCode/JuceHeader.h"
+
+#include "faust/gui/GUI.h"
+#include "faust/gui/PathBuilder.h"
+
+// Link AudioParameterBool with on/off parameter
+
+struct FaustPlugInAudioParameterBool : public juce::AudioParameterBool, public uiOwnedItem {
+    
+    FaustPlugInAudioParameterBool(GUI* gui, FAUSTFLOAT* zone, const std::string& path, const std::string& label)
+    :juce::AudioParameterBool(juce::ParameterID(path, /* versionHint */ 1), label, false), uiOwnedItem(gui, zone)
+    {}
+    
+    virtual ~FaustPlugInAudioParameterBool() {}
+    
+    void reflectZone() override
+    {
+        FAUSTFLOAT v = *fZone;
+        fCache = v;
+        setValueNotifyingHost(float(v));
+    }
+    
+    virtual void setValue (float newValue) override
+    {
+        modifyZone(FAUSTFLOAT(newValue));
+    }
+    
+};
+
+// Link AudioParameterFloat with range parameters
+
+struct FaustPlugInAudioParameterFloat : public juce::AudioParameterFloat, public uiOwnedItem {
+    
+    FaustPlugInAudioParameterFloat(GUI* gui, FAUSTFLOAT* zone, const std::string& path, const std::string& label, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+    :juce::AudioParameterFloat(juce::ParameterID(path, /* versionHint */ 1), label, float(min), float(max), float(init)), uiOwnedItem(gui, zone)
+    {}
+    
+    virtual ~FaustPlugInAudioParameterFloat() {}
+    
+    void reflectZone() override
+    {
+        FAUSTFLOAT v = *fZone;
+        fCache = v;
+        if (v >= range.start && v <= range.end) {
+            setValueNotifyingHost(range.convertTo0to1(float(v)));
+        }
+    }
+    
+    virtual void setValue (float newValue) override
+    {
+        modifyZone(FAUSTFLOAT(range.convertFrom0to1(newValue)));
+    }
+    
+};
+
+// A class to create AudioProcessorParameter objects for each zone
+
+class JuceParameterUI : public GUI, public PathBuilder {
+    
+    private:
+        
+        juce::AudioProcessor* fProcessor;
+        
+    public:
+        
+        JuceParameterUI(juce::AudioProcessor* processor):fProcessor(processor)
+        {}
+    
+        virtual ~JuceParameterUI() {}
+        
+        // -- widget's layouts
+        
+        virtual void openTabBox(const char* label)
+        {
+            pushLabel(label);
+        }
+        virtual void openHorizontalBox(const char* label)
+        {
+            pushLabel(label);
+        }
+        virtual void openVerticalBox(const char* label)
+        {
+            pushLabel(label);
+        }
+        virtual void closeBox()
+        {
+            popLabel();
+        }
+        
+        // -- active widgets
+        
+        virtual void addButton(const char* label, FAUSTFLOAT* zone)
+        {
+            fProcessor->addParameter(new FaustPlugInAudioParameterBool(this, zone, buildPath(label), label));
+        }
+        virtual void addCheckButton(const char* label, FAUSTFLOAT* zone)
+        {
+            fProcessor->addParameter(new FaustPlugInAudioParameterBool(this, zone, buildPath(label), label));
+        }
+        
+        virtual void addVerticalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+        {
+            fProcessor->addParameter(new FaustPlugInAudioParameterFloat(this, zone, buildPath(label), label, init, min, max, step));
+        }
+        
+        virtual void addHorizontalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+        {
+            fProcessor->addParameter(new FaustPlugInAudioParameterFloat(this, zone, buildPath(label), label, init, min, max, step));
+        }
+        
+        virtual void addNumEntry(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+        {
+            fProcessor->addParameter(new FaustPlugInAudioParameterFloat(this, zone, buildPath(label), label, init, min, max, step));
+        }
+        
+        // -- passive widgets
+        
+        virtual void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max)
+        {
+            fProcessor->addParameter(new FaustPlugInAudioParameterFloat(this, zone, buildPath(label), label, 0, min, max, 0));
+        }
+        
+        virtual void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max)
+        {
+            fProcessor->addParameter(new FaustPlugInAudioParameterFloat(this, zone, buildPath(label), label, 0, min, max, 0));
+        }
+    
+};
+
+#endif
+/**************************  END  JuceParameterUI.h **************************/

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

@@ -0,0 +1,103 @@
+/************************** BEGIN JuceReader.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 __JuceReader__
+#define __JuceReader__
+
+#include <assert.h>
+
+#include "../JuceLibraryCode/JuceHeader.h"
+
+#include "faust/gui/Soundfile.h"
+
+struct JuceReader : public SoundfileReader {
+    
+    juce::AudioFormatManager fFormatManager;
+    
+    JuceReader() { fFormatManager.registerBasicFormats(); }
+    virtual ~JuceReader()
+    {}
+    
+    bool checkFile(const std::string& path_name) override
+    {
+        juce::File file = juce::File::getCurrentWorkingDirectory().getChildFile(path_name);
+        if (file.existsAsFile()) {
+            return true;
+        } else {
+            //std::cerr << "ERROR : cannot open '" << path_name << "'" << std::endl;
+            return false;
+        }
+    }
+    
+    void getParamsFile(const std::string& path_name, int& channels, int& length) override
+    {
+        std::unique_ptr<juce::AudioFormatReader> formatReader (fFormatManager.createReaderFor (juce::File::getCurrentWorkingDirectory().getChildFile(path_name)));
+        channels = int(formatReader->numChannels);
+        length = int(formatReader->lengthInSamples);
+    }
+    
+    void readFile(Soundfile* soundfile, const std::string& path_name, int part, int& offset, int max_chan) override
+    {
+        std::unique_ptr<juce::AudioFormatReader> formatReader (fFormatManager.createReaderFor (juce::File::getCurrentWorkingDirectory().getChildFile(path_name)));
+        
+        soundfile->fLength[part] = int(formatReader->lengthInSamples);
+        soundfile->fSR[part] = int(formatReader->sampleRate);
+        soundfile->fOffset[part] = offset;
+        
+        void* buffers;
+        if (soundfile->fIsDouble) {
+            buffers = alloca(soundfile->fChannels * sizeof(double*));
+            soundfile->getBuffersOffsetReal<double>(buffers, offset);
+        } else {
+            buffers = alloca(soundfile->fChannels * sizeof(float*));
+            soundfile->getBuffersOffsetReal<float>(buffers, offset);
+        }
+        
+        if (formatReader->read(reinterpret_cast<int *const *>(buffers), int(formatReader->numChannels), 0, int(formatReader->lengthInSamples), false)) {
+            
+            // Possibly convert samples
+            if (!formatReader->usesFloatingPointData) {
+                for (int chan = 0; chan < int(formatReader->numChannels); ++chan) {
+                    if (soundfile->fIsDouble) {
+                        // TODO
+                    } else {
+                        float* buffer = &(static_cast<float**>(soundfile->fBuffers))[chan][soundfile->fOffset[part]];
+                        juce::FloatVectorOperations::convertFixedToFloat(buffer, reinterpret_cast<const int*>(buffer),
+                                                                         1.0f/0x7fffffff, int(formatReader->lengthInSamples));
+                    }
+                }
+            }
+            
+        } else {
+            std::cerr << "Error reading the file : " << path_name << std::endl;
+        }
+            
+        // Update offset
+        offset += soundfile->fLength[part];
+    }
+    
+};
+
+#endif
+/**************************  END  JuceReader.h **************************/

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

@@ -0,0 +1,88 @@
+/************************** BEGIN JuceStateUI.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 JuceStateUI_H
+#define JuceStateUI_H
+
+#include "../JuceLibraryCode/JuceHeader.h"
+
+#include "faust/gui/MapUI.h"
+
+// A class to save/restore DSP state using JUCE, which also set default values at construction time.
+
+struct JuceStateUI : public MapUI {
+    
+    bool fRestored;
+    
+    JuceStateUI():fRestored(false) {}
+    virtual ~JuceStateUI() {}
+    
+    void getStateInformation (juce::MemoryBlock& destData)
+    {
+        juce::MemoryOutputStream stream (destData, true);
+        
+        // Write path and values
+        if (sizeof(FAUSTFLOAT) == sizeof(float)) {
+            for (const auto& it : getFullpathMap()) {
+                stream.writeString(it.first);
+                stream.writeFloat(*it.second);
+            }
+        } else {
+            for (const auto& it : getFullpathMap()) {
+                stream.writeString(it.first);
+                stream.writeDouble(*it.second);
+            }
+        }
+    }
+    
+    void setStateInformation (const void* data, int sizeInBytes)
+    {
+        fRestored = true;
+        juce::MemoryInputStream stream (data, static_cast<size_t> (sizeInBytes), false);
+        std::string path;
+        
+        // Read path then value and try to restore them
+        if (sizeof(FAUSTFLOAT) == sizeof(float)) {
+            while ((path = stream.readString().toStdString()) != "") {
+                setParamValue(path, stream.readFloat());
+            }
+        } else {
+            while ((path = stream.readString().toStdString()) != "") {
+                setParamValue(path, stream.readDouble());
+            }
+        }
+    }
+    
+    // -- active widgets
+    // use MapUI derived methods
+    
+    // -- passive widgets
+    // empty si we don't want to save/restore them
+    void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT fmin, FAUSTFLOAT fmax) {}
+    void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT fmin, FAUSTFLOAT fmax) {}
+    
+};
+
+#endif
+/**************************  END  JuceStateUI.h **************************/