cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/owl.cpp

@@ -0,0 +1,345 @@
+/************************************************************************
+ IMPORTANT NOTE : this file contains two clearly delimited sections :
+ the ARCHITECTURE section (in two parts) and the USER section. Each section
+ is governed by its own copyright and license. Please check individually
+ each section for license and copyright information.
+ *************************************************************************/
+
+/******************* BEGIN owl.cpp ****************/
+/************************************************************************
+ FAUST Architecture File
+ Copyright (C) 2003-2019 GRAME, Centre National de Creation Musicale
+ ---------------------------------------------------------------------
+ This Architecture section is free software; you can redistribute it
+ and/or modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 3 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 General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with this program; If not, see <http://www.gnu.org/licenses/>.
+ 
+ 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 __FaustPatch_h__
+#define __FaustPatch_h__
+
+#include <new>
+#include <cstddef>
+#include <string.h>
+#include <strings.h>
+#include "Patch.h"
+
+#ifndef __FaustCommonInfrastructure__
+#define __FaustCommonInfrastructure__
+
+#include "faust/dsp/dsp.h"
+#include "faust/gui/UI.h"
+
+struct Meta
+{
+    virtual void declare(const char* key, const char* value) = 0;
+};
+
+/**************************************************************************************
+ 
+	OwlParameter : object used by OwlUI to ensures the connection between an owl parameter
+	and a faust widget
+	
+ ***************************************************************************************/
+
+class OwlParameter
+{
+    protected:
+    
+        Patch*           fPatch;     // needed to register and read owl parameters
+        PatchParameterId fParameter; // OWL parameter code : PARAMETER_A,...
+        FAUSTFLOAT*      fZone;      // Faust widget zone
+        const char*      fLabel;     // Faust widget label
+        float            fMin;       // Faust widget minimal value
+        float            fSpan;      // Faust widget value span (max-min)
+        
+    public:
+    
+        OwlParameter()
+        : fPatch(0), fParameter(PARAMETER_A), fZone(0), fLabel(""), fMin(0), fSpan(1) {}
+    
+        OwlParameter(const OwlParameter& w)
+        : fPatch(w.fPatch), fParameter(w.fParameter), fZone(w.fZone), fLabel(w.fLabel), fMin(w.fMin), fSpan(w.fSpan) {}
+    
+        OwlParameter(Patch* pp, PatchParameterId param, FAUSTFLOAT* z, const char* l, float lo, float hi) :
+        fPatch(pp), fParameter(param), fZone(z), fLabel(l), fMin(lo), fSpan(hi-lo) {}
+    
+        void bind() { fPatch->registerParameter(fParameter, fLabel); }
+        void update() { *fZone = fMin + fSpan*fPatch->getParameterValue(fParameter); }
+    
+};
+
+class OwlButton
+{
+    protected:
+    
+        Patch*        fPatch;  // needed to register and read owl parameters
+        PatchButtonId fButton; // OWL button id : PUSHBUTTON, ...
+        FAUSTFLOAT*   fZone;   // Faust widget zone
+        const char*   fLabel;  // Faust widget label
+    
+    public:
+    
+        OwlButton() :
+        fPatch(0), fButton(PUSHBUTTON), fZone(0), fLabel("") {}
+    
+        OwlButton(const OwlButton& w) :
+        fPatch(w.fPatch), fButton(w.fButton), fZone(w.fZone), fLabel(w.fLabel) {}
+    
+        OwlButton(Patch* pp, PatchButtonId button, FAUSTFLOAT* z, const char* l)
+        :fPatch(pp), fButton(button), fZone(z), fLabel(l) {}
+    
+        void bind() {}
+        void update() { *fZone = fPatch->isButtonPressed(fButton); }
+};
+
+/**************************************************************************************
+ 
+ OwlUI : Faust User Interface builder. Passed to buildUserInterface OwlUI ensures
+ the mapping between owl parameters and Faust widgets. It relies on specific
+ metadata "...[OWL:PARAMETER_X]..." in widget's label for that. For example any
+ Faust widget with metadata [OWL:PARAMETER_B] will be controlled by PARAMETER_B
+ (the second knob).
+	
+ ***************************************************************************************/
+
+// The maximun number of mappings between owl parameters and faust widgets
+#define MAXOWLPARAMETERS 40
+#define MAXOWLBUTTONS    2
+#define NO_PARAMETER     ((PatchParameterId)-1)
+#define NO_BUTTON        ((PatchButtonId)-1)
+
+class OwlUI : public UI
+{
+    private:
+    
+        Patch*           fPatch;
+        PatchParameterId fParameter;                        // current parameter ID, value NO_PARAMETER means not set
+        int              fParameterIndex;                   // number of OwlParameters collected so far
+        OwlParameter     fParameterTable[MAXOWLPARAMETERS]; // kind of static list of OwlParameters
+        PatchButtonId    fButton;
+        int              fButtonIndex;
+        OwlButton        fButtonTable[MAXOWLBUTTONS];
+        
+        // check if the widget is an Owl parameter and, if so, add the corresponding OwlParameter
+        void addOwlParameter(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT lo, FAUSTFLOAT hi)
+        {
+            if ((fParameter >= PARAMETER_A) && (fParameterIndex < MAXOWLPARAMETERS)) {
+                fParameterTable[fParameterIndex] = OwlParameter(fPatch, fParameter, zone, label, lo, hi);
+                fParameterTable[fParameterIndex].bind();
+                fParameterIndex++;
+            }
+            fParameter = NO_PARAMETER; 		// clear current parameter ID
+        }
+        void addOwlButton(const char* label, FAUSTFLOAT* zone)
+        {
+            if ((fButton >= PUSHBUTTON) && (fButtonIndex < MAXOWLBUTTONS)) {
+                fButtonTable[fButtonIndex] = OwlButton(fPatch, fButton, zone, label);
+                fButtonTable[fButtonIndex].bind();
+                fButtonIndex++;
+            }
+            fButton = NO_BUTTON;            // clear current button ID
+        }
+        
+        // we dont want to create a widget by-ut we clear the current parameter ID just in case
+        void skip()
+        {
+            fParameter = NO_PARAMETER; 		// clear current parameter ID
+            fButton = NO_BUTTON;
+        }
+        
+    public:
+        
+        OwlUI(Patch* pp) : fPatch(pp), fParameter(NO_PARAMETER), fParameterIndex(0), fButton(NO_BUTTON), fButtonIndex(0) {}
+        
+        virtual ~OwlUI() {}
+        
+        // should be called before compute() to update widget's zones registered as Owl parameters
+        void update()
+        {
+            for (int i = 0; i < fParameterIndex; i++) fParameterTable[i].update();
+            for (int i = 0; i < fButtonIndex; i++) fButtonTable[i].update();
+        }
+        
+        //---------------------- virtual methods called by buildUserInterface ----------------
+        
+        // -- widget's layouts
+        
+        virtual void openTabBox(const char* label) {}
+        virtual void openHorizontalBox(const char* label) {}
+        virtual void openVerticalBox(const char* label) {}
+        virtual void closeBox() {}
+        
+        // -- active widgets
+        
+        virtual void addButton(const char* label, FAUSTFLOAT* zone) { addOwlButton(label, zone); }
+        virtual void addCheckButton(const char* label, FAUSTFLOAT* zone) { addOwlButton(label, zone); }
+        virtual void addVerticalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT lo, FAUSTFLOAT hi, FAUSTFLOAT step) { addOwlParameter(label, zone, lo, hi); }
+        virtual void addHorizontalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT lo, FAUSTFLOAT hi, FAUSTFLOAT step) { addOwlParameter(label, zone, lo, hi); }
+        virtual void addNumEntry(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT lo, FAUSTFLOAT hi, FAUSTFLOAT step) { addOwlParameter(label, zone, lo, hi); }
+        
+        // -- passive widgets
+        
+        virtual void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT lo, FAUSTFLOAT hi) { skip(); }
+        virtual void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT lo, FAUSTFLOAT hi) { skip(); }
+        
+        // -- soundfiles
+        virtual void addSoundfile(const char* label, const char* filename, Soundfile** sf_zone) {}
+        
+        // -- metadata declarations
+        
+        virtual void declare(FAUSTFLOAT* z, const char* k, const char* id)
+        {
+            if (strcasecmp(k,"OWL") == 0) {
+                if (strncasecmp(id, "PARAMETER_", 10) == 0)
+                    id += 10;
+                if (strcasecmp(id,"A") == 0)  fParameter = PARAMETER_A;
+                else if (strcasecmp(id,"B") == 0)  fParameter = PARAMETER_B;
+                else if (strcasecmp(id,"C") == 0)  fParameter = PARAMETER_C;
+                else if (strcasecmp(id,"D") == 0)  fParameter = PARAMETER_D;
+                else if (strcasecmp(id,"E") == 0)  fParameter = PARAMETER_E;
+                else if (strcasecmp(id,"F") == 0)  fParameter = PARAMETER_F;
+                else if (strcasecmp(id,"G") == 0)  fParameter = PARAMETER_G;
+                else if (strcasecmp(id,"H") == 0)  fParameter = PARAMETER_H;
+                else if (strcasecmp(id,"PUSH") == 0)  fButton = PUSHBUTTON;
+                else if (strcasecmp(id,"BYPASS") == 0)  fButton = BYPASS_BUTTON;
+            }
+        }
+};
+
+/* Simple heap based memory manager.
+ * Uses overloaded new/delete operators on OWL hardware.
+ */
+struct OwlMemoryManager : public dsp_memory_manager {
+    
+    void* allocate(size_t size)
+    {
+        void* res = new uint8_t[size];
+        return res;
+    }
+    
+    virtual void destroy(void* ptr)
+    {
+        delete (uint8_t*)ptr;
+    }
+};
+
+#endif // __FaustCommonInfrastructure__
+/******************************************************************************
+ *******************************************************************************
+ 
+ VECTOR INTRINSICS
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+<<includeIntrinsic>>
+
+/********************END ARCHITECTURE SECTION (part 1/2)****************/
+
+/**************************BEGIN USER SECTION **************************/
+
+<<includeclass>>
+
+/***************************END USER SECTION ***************************/
+
+/*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
+
+/**************************************************************************************
+ 
+	FaustPatch : an OWL patch that calls Faust generated DSP code
+	
+ ***************************************************************************************/
+
+class FaustPatch : public Patch
+{
+    
+    private:
+    
+        mydsp* fDSP;
+        OwlUI fUI;
+        OwlMemoryManager fMem;
+        
+    public:
+        
+        FaustPatch() : fUI(this)
+        {
+            fDSP = new mydsp();
+            mydsp::fManager = &fMem;                    // set custom memory manager
+            mydsp::classInit(int(getSampleRate()));     // initialise static tables
+            fDSP->instanceInit(int(getSampleRate()));   // initialise DSP instance
+            fDSP->buildUserInterface(&fUI);             // Map OWL parameters
+        }
+        
+        ~FaustPatch()
+        {
+            delete fDSP;
+            mydsp::classDestroy(); // destroy static tables
+        }
+        
+        void processAudio(AudioBuffer &buffer)
+        {
+            // Reasonably assume we will not have more than 32 channels
+            float* ins[32];
+            float* outs[32];
+            int n = buffer.getChannels();
+            
+            if ((fDSP->getNumInputs() < 32) && (fDSP->getNumOutputs() < 32)) {
+                
+                // create the table of input channels
+                for (int ch = 0; ch < fDSP->getNumInputs(); ++ch) {
+                    ins[ch] = buffer.getSamples(ch%n);
+                }
+                
+                // create the table of output channels
+                for (int ch = 0; ch < fDSP->getNumOutputs(); ++ch) {
+                    outs[ch] = buffer.getSamples(ch%n);
+                }
+                
+                // read OWL parameters and updates corresponding Faust Widgets zones
+                fUI.update();
+                
+                // Process the audio samples
+                fDSP->compute(buffer.getSize(), ins, outs);
+            }
+        }
+    
+};
+
+extern "C" {
+    void doSetButton(uint8_t id, uint16_t state, uint16_t samples);
+    int owl_pushbutton(int value){
+        static bool state = 0;
+        static uint16_t counter = 0;
+        value = (bool)value;
+        if (state != value) {
+            state = value;
+            doSetButton(PUSHBUTTON, state, counter);
+        }
+        if (++counter > getProgramVector()->audio_blocksize) {
+            counter = 0;
+        }
+        return value;
+    }
+}
+
+#endif // __FaustPatch_h__
+
+/******************* END owl.cpp ****************/
+

cyfaust/resources/architecture/pa-gtk.cpp

@@ -0,0 +1,119 @@
+/************************************************************************
+ IMPORTANT NOTE : this file contains two clearly delimited sections :
+ the ARCHITECTURE section (in two parts) and the USER section. Each section
+ is governed by its own copyright and license. Please check individually
+ each section for license and copyright information.
+ *************************************************************************/
+
+/******************* BEGIN pa-gtk.cpp ****************/
+/************************************************************************
+ FAUST Architecture File
+ Copyright (C) 2003-2019 GRAME, Centre National de Creation Musicale
+ ---------------------------------------------------------------------
+ This Architecture section is free software; you can redistribute it
+ and/or modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 3 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 General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with this program; If not, see <http://www.gnu.org/licenses/>.
+ 
+ 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.
+ 
+ ************************************************************************
+ ************************************************************************/
+
+#include <libgen.h>
+#include <iostream>
+
+#include "faust/gui/FUI.h"
+#include "faust/misc.h"
+#include "faust/audio/portaudio-dsp.h"
+#include "faust/gui/GTKUI.h"
+
+#ifdef OSCCTRL
+#include "faust/gui/OSCUI.h"
+#endif
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ VECTOR INTRINSICS
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+<<includeIntrinsic>>
+
+/********************END ARCHITECTURE SECTION (part 1/2)****************/
+
+/**************************BEGIN USER SECTION **************************/
+
+<<includeclass>>
+
+/***************************END USER SECTION ***************************/
+
+/*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
+
+mydsp DSP;
+std::list<GUI*> GUI::fGuiList;
+ztimedmap GUI::gTimedZoneMap;
+
+//-------------------------------------------------------------------------
+// 									MAIN
+//-------------------------------------------------------------------------
+
+int main(int argc, char *argv[])
+{
+	char appname[256];
+	char rcfilename[256];
+	char* home = getenv("HOME");
+
+	snprintf(appname, 256, "%s", basename(argv[0]));
+	snprintf(rcfilename, 256, "%s/.%src", home, appname);
+
+	GUI* interface = new GTKUI (appname, &argc, &argv);
+	FUI* finterface	= new FUI();
+	DSP.buildUserInterface(interface);
+	DSP.buildUserInterface(finterface);
+
+#ifdef OSCCTRL
+	GUI* oscinterface = new OSCUI(appname, argc, argv);
+	DSP.buildUserInterface(oscinterface);
+#endif
+
+    long srate = (long)lopt(argv, "--frequency", 44100);
+    int	fpb = lopt(argv, "--buffer", 128);
+
+	portaudio audio (srate, fpb);
+	audio.init(appname, &DSP);
+	finterface->recallState(rcfilename);
+	audio.start();
+
+#ifdef OSCCTRL
+	oscinterface->run();
+#endif
+	interface->run();
+
+	audio.stop();
+	finterface->saveState(rcfilename);
+    
+   // desallocation
+    delete interface;
+    delete finterface;
+#ifdef OSCCTRL
+	 delete oscinterface;
+#endif
+
+  	return 0;
+}
+
+/******************* END pa-gtk.cpp ****************/