cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/minimal-effect.c

@@ -0,0 +1,149 @@
+/************************************************************************
+ 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 minimal-effect.c ****************/
+
+/************************************************************************
+ 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 <algorithm>
+
+#include "faust/dsp/dsp.h"
+#include "faust/gui/UI.h"
+#include "faust/gui/meta.h"
+#include "faust/gui/CGlue.h"
+
+#define max(a,b) ((a < b) ? b : a)
+#define min(a,b) ((a < b) ? a : b)
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ VECTOR INTRINSICS
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+<<includeIntrinsic>>
+
+/********************END ARCHITECTURE SECTION (part 1/2)****************/
+
+/**************************BEGIN USER SECTION **************************/
+
+<<includeclass>>
+
+/***************************END USER SECTION ***************************/
+
+/*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
+
+class Cdsp : public dsp {
+    
+    private:
+    
+        mydsp* fDSP;
+    
+    public:
+    
+        Cdsp():fDSP(newmydsp())
+        {}
+    
+        virtual ~Cdsp()
+        {
+            deletemydsp(fDSP);
+        }
+    
+        virtual int getNumInputs() { return getNumInputsmydsp(fDSP); }
+    
+        virtual int getNumOutputs() { return getNumOutputsmydsp(fDSP); }
+    
+        virtual void buildUserInterface(UI* interface)
+        {
+            UIGlue glue;
+            buildUIGlue(&glue, interface, sizeof(FAUSTFLOAT) == 8);
+            buildUserInterfacemydsp(fDSP, &glue);
+        }
+    
+        virtual int getSampleRate()
+        {
+            return getSampleRatemydsp(fDSP);
+        }
+    
+        virtual void init(int samplingRate)
+        {
+            initmydsp(fDSP, samplingRate);
+        }
+    
+        static void classInit(int samplingRate)
+        {
+            classInitmydsp(samplingRate);
+        }
+    
+        virtual void instanceInit(int samplingRate)
+        {
+            instanceInitmydsp(fDSP, samplingRate);
+        }
+    
+        virtual void instanceConstants(int samplingRate)
+        {
+            instanceConstantsmydsp(fDSP, samplingRate);
+        }
+    
+        virtual void instanceResetUserInterface()
+        {
+            instanceResetUserInterfacemydsp(fDSP);
+        }
+    
+        virtual void instanceClear()
+        {
+            instanceClearmydsp(fDSP);
+        }
+    
+        virtual Cdsp* clone()
+        {
+            return new Cdsp();
+        }
+    
+        virtual void metadata(Meta* m)
+        {
+            MetaGlue glue;
+            buildMetaGlue(&glue, m);
+            metadatamydsp(&glue);
+        }
+    
+        virtual void compute(int count, FAUSTFLOAT** input, FAUSTFLOAT** output)
+        {
+            computemydsp(fDSP, count, input, output);
+        }
+    
+};
+
+// Factory API
+dsp* createmydsp() { return new Cdsp(); }
+
+/******************** END minimal-effect.c ****************/

cyfaust/resources/architecture/minimal-effect.cpp

@@ -0,0 +1,70 @@
+/************************************************************************
+ 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 minimal-effect.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 <algorithm>
+
+#include "faust/gui/UI.h"
+#include "faust/gui/meta.h"
+#include "faust/dsp/dsp.h"
+
+#if defined(SOUNDFILE)
+#include "faust/gui/SoundUI.h"
+#endif
+
+using std::max;
+using std::min;
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ VECTOR INTRINSICS
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+<<includeIntrinsic>>
+
+/********************END ARCHITECTURE SECTION (part 1/2)****************/
+
+/**************************BEGIN USER SECTION **************************/
+
+<<includeclass>>
+
+/***************************END USER SECTION ***************************/
+
+/*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
+
+// Factory API
+dsp* createmydsp() { return new mydsp(); }
+
+/******************* END minimal-effect.cpp ****************/

cyfaust/resources/architecture/minimal-fixed-point.cpp

@@ -0,0 +1,195 @@
+/************************************************************************
+ 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 minimal-fixed-point.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 <algorithm>
+#include <cmath>
+
+#include "faust/gui/PrintUI.h"
+#include "faust/gui/UI.h"
+#include "faust/gui/meta.h"
+#include "faust/dsp/dsp.h"
+#include "faust/audio/dummy-audio.h"
+#include "faust/dsp/one-sample-dsp.h"
+
+#if defined(SOUNDFILE)
+#include "faust/gui/SoundUI.h"
+#endif
+
+#include "ap_fixed.h"
+
+typedef ap_fixed<32, 8, AP_RND_CONV, AP_SAT> fixpoint_t;
+
+// fx version
+inline fixpoint_t fabsfx(fixpoint_t x)
+{
+    return fixpoint_t(std::fabs(float(x)));
+}
+inline fixpoint_t acosfx(fixpoint_t x)
+{
+    return fixpoint_t(std::acos(float(x)));
+}
+inline fixpoint_t asinfx(fixpoint_t x)
+{
+    return fixpoint_t(std::asin(float(x)));
+}
+inline fixpoint_t atanfx(fixpoint_t x)
+{
+    return fixpoint_t(std::atan(float(x)));
+}
+inline fixpoint_t atan2fx(fixpoint_t x, fixpoint_t y)
+{
+    return fixpoint_t(std::atan2(float(x), float(y)));
+}
+inline fixpoint_t ceilfx(fixpoint_t x)
+{
+    return fixpoint_t(std::ceil(float(x)));
+}
+inline fixpoint_t cosfx(fixpoint_t x)
+{
+    return fixpoint_t(std::cos(float(x)));
+}
+inline fixpoint_t expfx(fixpoint_t x)
+{
+    return fixpoint_t(std::exp(float(x)));
+}
+inline fixpoint_t exp2fx(fixpoint_t x)
+{
+    return fixpoint_t(std::exp2(float(x)));
+}
+inline fixpoint_t exp10fx(fixpoint_t x)
+{
+#ifdef __APPLE__
+    return fixpoint_t(__exp10f(float(x)));
+#else
+    return fixpoint_t(exp10(float(x)));
+#endif
+}
+inline fixpoint_t floorfx(fixpoint_t x)
+{
+    return fixpoint_t(std::floor(float(x)));
+}
+inline fixpoint_t fmodfx(fixpoint_t x, fixpoint_t y)
+{
+    return fixpoint_t(std::fmod(float(x), float(y)));
+}
+inline fixpoint_t logfx(fixpoint_t x)
+{
+    return fixpoint_t(std::log(float(x)));
+}
+inline fixpoint_t log2fx(fixpoint_t x)
+{
+    return fixpoint_t(std::log2(float(x)));
+}
+inline fixpoint_t log10fx(fixpoint_t x)
+{
+    return fixpoint_t(std::log10(float(x)));
+}
+inline fixpoint_t powfx(fixpoint_t x, fixpoint_t y)
+{
+    return fixpoint_t(std::pow(float(x), float(y)));
+}
+inline fixpoint_t remainderfx(fixpoint_t x, fixpoint_t y)
+{
+    return fixpoint_t(std::remainder(float(x), float(y)));
+}
+inline fixpoint_t rintfx(fixpoint_t x)
+{
+    return fixpoint_t(std::rint(float(x)));
+}
+inline fixpoint_t roundfx(fixpoint_t x)
+{
+    return fixpoint_t(std::round(float(x)));
+}
+inline fixpoint_t sinfx(fixpoint_t x)
+{
+    return fixpoint_t(std::sin(float(x)));
+}
+inline fixpoint_t sqrtfx(fixpoint_t x)
+{
+    return fixpoint_t(std::sqrt(float(x)));
+}
+inline fixpoint_t tanfx(fixpoint_t x)
+{
+    return fixpoint_t(std::tan(float(x)));
+}
+// min/max
+inline fixpoint_t fminfx(fixpoint_t x, fixpoint_t y)
+{
+    return fixpoint_t(std::min(float(x), float(y)));
+}
+inline fixpoint_t fmaxfx(fixpoint_t x, fixpoint_t y)
+{
+    return fixpoint_t(std::max(float(x), float(y)));
+}
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ VECTOR INTRINSICS
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+<<includeIntrinsic>>
+
+/********************END ARCHITECTURE SECTION (part 1/2)****************/
+
+/**************************BEGIN USER SECTION **************************/
+
+<<includeclass>>
+
+/***************************END USER SECTION ***************************/
+
+/*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
+
+using namespace std;
+
+int main(int argc, char* argv[])
+{
+    mydsp DSP;
+    cout << "DSP size: " << sizeof(DSP) << " bytes\n";
+    
+    // Activate the UI, here that only print the control paths
+    PrintUI ui;
+    DSP.buildUserInterface(&ui);
+    
+    // Allocate the audio driver to render 5 buffers of 512 frames
+    dummyaudio audio(5);
+    audio.init("Test", static_cast<dsp*>(&DSP));
+    
+    // Render buffers...
+    audio.start();
+    audio.stop();
+}
+
+/******************* END minimal-fixed-point.cpp ****************/

cyfaust/resources/architecture/minimal-static.cpp

@@ -0,0 +1,160 @@
+/************************************************************************
+ 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 minimal-static.cpp ****************/
+/************************************************************************
+ FAUST Architecture File
+ Copyright (C) 2020 Jean Pierre Cimalando, 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 "faust/dsp/dsp.h"
+#include "faust/gui/UI.h"
+#include "faust/gui/meta.h"
+
+#define FAUST_UIMACROS 1
+
+// but we will ignore most of them
+#define FAUST_ADDBUTTON(l,f)
+#define FAUST_ADDCHECKBOX(l,f)
+#define FAUST_ADDVERTICALSLIDER(l,f,i,a,b,s)
+#define FAUST_ADDHORIZONTALSLIDER(l,f,i,a,b,s)
+#define FAUST_ADDNUMENTRY(l,f,i,a,b,s)
+#define FAUST_ADDVERTICALBARGRAPH(l,f,a,b)
+#define FAUST_ADDHORIZONTALBARGRAPH(l,f,a,b)
+
+/*
+faust -uim -a minimal-static.cpp noise.dsp -o noise.cpp && c++ -std=c++11 noise.cpp -o noise && ./noise
+faust -uim -a minimal-static.cpp clarinetMIDI.dsp -o clarinetMIDI.cpp && c++ -std=c++11 clarinetMIDI.cpp -o clarinetMIDI && ./clarinetMIDI
+faust -uim -a minimal-static.cpp vumeter.dsp -o vumeter.cpp && c++ -std=c++11 vumeter.cpp -o vumeter && ./vumeter
+*/
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ VECTOR INTRINSICS
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+<<includeIntrinsic>>
+
+/********************END ARCHITECTURE SECTION (part 1/2)****************/
+
+/**************************BEGIN USER SECTION **************************/
+
+<<includeclass>>
+
+/***************************END USER SECTION ***************************/
+
+/*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
+
+/*
+ Example: generate UI information into static metadata
+ */
+struct ControlDescription {
+    const char *type;
+    const char *ident;
+    const char *name;
+    const char *var;
+    float def;
+    float min;
+    float max;
+    float step;
+};
+
+static const ControlDescription actives[] = {
+#define ACTIVE_ELEMENT(type, ident, name, var, def, min, max, step) \
+{ #type, #ident, name, #var, def, min, max, step },
+    FAUST_LIST_ACTIVES(ACTIVE_ELEMENT)
+};
+static_assert(FAUST_ACTIVES == sizeof(actives) / sizeof(actives[0]), "incorrect size of result");
+
+static const ControlDescription passives[] = {
+#define PASSIVE_ELEMENT(type, ident, name, var, def, min, max, step) \
+{ #type, #ident, name, #var, def, min, max, step },
+    FAUST_LIST_PASSIVES(PASSIVE_ELEMENT)
+};
+static_assert(FAUST_PASSIVES == sizeof(passives) / sizeof(passives[0]), "incorrect size of result");
+
+/*
+ Example: generate UI actives into an enum
+ */
+enum {
+#define ACTIVE_ENUM_MEMBER(type, ident, name, var, def, min, max, step) \
+kActive_##ident,
+    FAUST_LIST_ACTIVES(ACTIVE_ENUM_MEMBER)
+    //
+    kNumActives,
+};
+static_assert(FAUST_ACTIVES == kNumActives, "incorrect size of result");
+
+int main(int argc, char* argv[])
+{
+    printf("=============================\n"
+           "DSP Static Information (-uim)\n"
+           "=============================\n"
+           "\n");
+    
+    printf("Number of actives: %d\n", FAUST_ACTIVES);
+    putchar('\n');
+    
+    for (int i = 0; i < FAUST_ACTIVES; ++i) {
+        printf("--- active number %d\n\n", i + 1);
+        
+        printf("Parameter name:             %s\n", actives[i].name);
+        printf("Kind of control:            %s\n", actives[i].type);
+        printf("Unique symbol:              %s\n", actives[i].ident);
+        printf("Name of instance variable:  %s\n", actives[i].var);
+        putchar('\n');
+        printf("Value range:                %g to %g\n", actives[i].min, actives[i].max);
+        printf("Default value:              %g\n", actives[i].def);
+        printf("Step:                       %g\n", actives[i].step);
+        putchar('\n');
+    }
+    
+    printf("Number of passives: %d\n", FAUST_PASSIVES);
+    putchar('\n');
+    
+    for (int i = 0; i < FAUST_PASSIVES; ++i) {
+        printf("--- passive number %d\n\n", i + 1);
+        
+        printf("Parameter name:             %s\n", passives[i].name);
+        printf("Kind of control:            %s\n", passives[i].type);
+        printf("Unique symbol:              %s\n", passives[i].ident);
+        printf("Name of instance variable:  %s\n", passives[i].var);
+        putchar('\n');
+        printf("Value range:                %g to %g\n", passives[i].min, passives[i].max);
+        printf("Default value:              %g\n", passives[i].def);
+        printf("Step:                       %g\n", passives[i].step);
+        putchar('\n');
+    }
+    
+    return 0;
+}
+
+/******************* END minimal-static.cpp ****************/
+

cyfaust/resources/architecture/minimal.c

@@ -0,0 +1,103 @@
+/************************************************************************
+ 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 minimal.c ****************/
+
+/************************************************************************
+ 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 <math.h>
+#include <stdio.h>
+
+#include "faust/gui/CInterface.h"
+
+#define max(a,b) ((a < b) ? b : a)
+#define min(a,b) ((a < b) ? a : b)
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ VECTOR INTRINSICS
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+<<includeIntrinsic>>
+
+/********************END ARCHITECTURE SECTION (part 1/2)****************/
+
+/**************************BEGIN USER SECTION **************************/
+
+<<includeclass>>
+
+/***************************END USER SECTION ***************************/
+
+/*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
+
+#define BUFFER_SIZE 64
+#define SAMPLE_RATE 44100
+
+int main(int argc, char* argv[])
+{
+    mydsp* dsp = newmydsp();
+    
+    printf("DSP inputs: %d\n", getNumInputsmydsp(dsp));
+    printf("DSP outputs: %d\n", getNumOutputsmydsp(dsp));
+    
+    // Init with audio driver SR
+    initmydsp(dsp, SAMPLE_RATE);
+    
+    // Compute one buffer
+    FAUSTFLOAT* inputs[getNumInputsmydsp(dsp)];
+    FAUSTFLOAT* outputs[getNumOutputsmydsp(dsp)];
+    for (int chan = 0; chan < getNumInputsmydsp(dsp); ++chan) {
+        inputs[chan] = malloc(sizeof(FAUSTFLOAT) * BUFFER_SIZE);
+    }
+    for (int chan = 0; chan < getNumOutputsmydsp(dsp); ++chan) {
+        outputs[chan] = malloc(sizeof(FAUSTFLOAT) * BUFFER_SIZE);
+    }
+    computemydsp(dsp, BUFFER_SIZE, inputs, outputs);
+    
+    // Print output buffers
+    for (int frame = 0; frame < BUFFER_SIZE; ++frame) {
+        for (int chan = 0; chan < getNumOutputsmydsp(dsp); ++chan) {
+            printf("Audio output chan: %d sample: %f\n", chan, outputs[chan][frame]);
+        }
+    }
+    
+    for (int chan = 0; chan < getNumInputsmydsp(dsp); ++chan) {
+        free(inputs[chan]);
+    }
+    for (int chan = 0; chan < getNumOutputsmydsp(dsp); ++chan) {
+        free(outputs[chan]);
+    }
+    deletemydsp(dsp);
+}
+
+/******************** END minimal.c ****************/