cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/csound.cpp

@@ -0,0 +1,245 @@
+/************************************************************************
+ 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 csound.cpp ****************/
+
+/************************************************************************
+ FAUST Architecture File
+ Copyright (C) 2010-2019 V. Lazzarini and GRAME
+ ---------------------------------------------------------------------
+ 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.
+
+ ************************************************************************
+ ************************************************************************/
+
+//==============================================================================
+//
+//          CSOUND6 architecture file for FAUST
+//          Y. Orlarey & V. Lazzarini
+//
+//          Usage : faust -uim -a csound.cpp <myfx>.dsp -o <myfx>.cpp
+//                  g++ -O3 -DOPCODE_NAME=<myfx> -c <myfx>.cpp -o <myfx>.o
+//                  ld -E --shared <myfx>.o -o <myfx>.so
+//
+//          History :
+//          - 28/04/09 : first version
+//          - 29/04/09 : dynamic allocation
+//          - 10/07/14 : updated to Csound6 (Paul Batchelor)
+//          - 29/03/20 : correct entry point
+//
+//==============================================================================
+
+#include <new>
+#include <vector>
+
+#include "csdl.h"                        /* CSOUND plugin API header */
+
+// used to transform a symbol in a string
+#define sym(name) xsym(name)
+#define xsym(name) #name
+
+// make sure we use csound floats
+#define FAUSTFLOAT MYFLT
+
+// we require macro declarations
+#define FAUST_UIMACROS
+
+// 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)
+
+#include "faust/misc.h"
+#include "faust/dsp/dsp.h"
+#include "faust/gui/meta.h"
+#include "faust/gui/DecoratorUI.h"
+
+/**
+ * A UI that simply collects the active zones in a vector
+ * and provides a method to copy the Csound controls
+ */
+class CSUI : public GenericUI
+{
+    private:
+    
+        std::vector<FAUSTFLOAT*>  vZone;
+
+    public:
+
+        // -- active widgets
+
+        virtual void addButton(const char* label, FAUSTFLOAT* zone) { vZone.push_back(zone); }
+        virtual void addCheckButton(const char* label, FAUSTFLOAT* zone) { vZone.push_back(zone); }
+    
+        virtual void addVerticalSlider(const char* label,
+                                       FAUSTFLOAT* zone,
+                                       FAUSTFLOAT init,
+                                       FAUSTFLOAT min,
+                                       FAUSTFLOAT max,
+                                       FAUSTFLOAT step)
+        {
+            vZone.push_back(zone);
+        }
+        virtual void addHorizontalSlider(const char* label,
+                                         FAUSTFLOAT* zone,
+                                         FAUSTFLOAT init,
+                                         FAUSTFLOAT min,
+                                         FAUSTFLOAT max,
+                                         FAUSTFLOAT step)
+        {
+            vZone.push_back(zone);
+        }
+        virtual void addNumEntry(const char* label,
+                                 FAUSTFLOAT* zone,
+                                 FAUSTFLOAT init,
+                                 FAUSTFLOAT min,
+                                 FAUSTFLOAT max,
+                                 FAUSTFLOAT step)
+        {
+            vZone.push_back(zone);
+        }
+
+        void copyfrom(MYFLT* mem[])
+        {
+            for (unsigned int i = 0; i < vZone.size(); i++) {
+                if (*(mem[i]) != FL(-1.)) {
+                    *vZone[i] = *(mem[i]);
+                }
+            }
+        }
+};
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ VECTOR INTRINSICS
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+<<includeIntrinsic>>
+
+/********************END ARCHITECTURE SECTION (part 1/2)****************/
+
+/**************************BEGIN USER SECTION **************************/
+
+<<includeclass>>
+
+/***************************END USER SECTION ***************************/
+
+/*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
+
+struct dataspace {
+    OPDS      h;                          /* basic attributes  */
+#if (FAUST_OUTPUTS > 0)                   /* omit 0 size array */
+    MYFLT*    aout[FAUST_OUTPUTS];        /* output buffers    */
+#endif
+#if (FAUST_INPUTS > 0)                    /* omit 0 size array */
+    MYFLT*    ain[FAUST_INPUTS];          /* input buffers     */
+#endif
+#if (FAUST_ACTIVES > 0)                   /* omit 0 size array */
+    MYFLT*    ktl[FAUST_ACTIVES];         /* controls          */
+#endif
+    dsp*      DSP;                        /* the Faust generated object */
+    CSUI*     interface;                  /* do the mapping between CSound controls and DSP fields */
+    AUXCH     dspmem;                     /* aux memory allocated once to store the DSP object */
+    AUXCH     intmem;                     /* aux memory allocated once to store the interface object */
+/* Dummies to satisfy the compiler for "zero sized" arrays. */
+#if (FAUST_OUTPUTS == 0)
+    MYFLT*    aout[1];
+#endif
+#if (FAUST_INPUTS == 0)
+    MYFLT*    ain[1];
+#endif
+#if (FAUST_ACTIVES == 0)
+    MYFLT*    ktl[1];
+#endif
+};
+
+/**
+ * Creates a "aaakkkk" CSound description string. Note that
+ * these string will never be released. Potential memory leak.
+ */
+static char* makeDescription(int numa, int numk = 0)
+{
+    char* str = (char*)malloc(numa+numk+1); // NEED TO BE CHANGED ?
+    if (str) {
+        for (int i = 0; i < numa; i++) str[i] = 'a';
+        for (int i = 0; i < numk; i++) str[numa+i] = 'J';
+        str[numa+numk] = 0;
+    }
+    return str;
+}
+
+/**
+ * CSOUND callback that allocates and initializes
+ * the FAUST generated DSP object and it's CSound interface
+ */
+static int init(CSOUND* csound, dataspace* p)
+{
+    if (p->dspmem.auxp == NULL)
+        csound->AuxAlloc(csound, sizeof(mydsp), &p->dspmem);
+
+    if (p->intmem.auxp == NULL)
+        csound->AuxAlloc(csound, sizeof(CSUI), &p->intmem);
+
+    p->DSP = new (p->dspmem.auxp) mydsp;
+    p->interface = new (p->intmem.auxp) CSUI;
+
+    if ((p->DSP == 0) | (p->interface == 0)) return NOTOK;
+
+    p->DSP->init((int)csound->GetSr(csound));
+    p->DSP->buildUserInterface(p->interface);
+
+    return OK;
+}
+
+/**
+ * CSound callback that process the samples by updating
+ * the controls values and calling the compute() method
+ * of the DSP object. (Assume MYFLT = FAUSTFLOAT)
+ */
+static int process32bits(CSOUND* csound, dataspace* p)
+{
+    AVOIDDENORMALS;
+
+    // update all the control values
+    p->interface->copyfrom(p->ktl);
+
+    p->DSP->compute(csound->GetKsmps(csound), p->ain, p->aout);
+    return OK;
+}
+
+extern "C" {
+    static OENTRY localops[] = {
+        {(char*)sym(OPCODE_NAME), sizeof(dataspace), 0, 3, makeDescription(FAUST_OUTPUTS), makeDescription(FAUST_INPUTS, FAUST_ACTIVES),
+            (SUBR)init, (SUBR)process32bits }
+    };
+    LINKAGE
+}
+
+/******************** END csound.cpp ****************/

cyfaust/resources/architecture/csvplot.cpp

@@ -0,0 +1,227 @@
+/************************************************************************
+ 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 cvsplot.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 <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <iostream>
+#include <limits>
+#include <string>
+#include <iomanip>
+
+#include "faust/audio/channels.h"
+#include "faust/dsp/dsp.h"
+#include "faust/gui/console.h"
+#include "faust/gui/DecoratorUI.h"
+#include "faust/misc.h"
+
+#ifdef SOUNDFILE
+#include "faust/gui/SoundUI.h"
+#endif
+
+using namespace std;
+
+// A class to display Bargraph values
+struct DisplayUI : public GenericUI {
+    
+    map<string, FAUSTFLOAT*> fTable;
+    
+    // -- passive widgets
+    virtual void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max)
+    {
+        fTable[label] = zone;
+    }
+    virtual void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max)
+    {
+        fTable[label] = zone;
+    }
+    
+    void displayHeaders()
+    {
+        int c = 0;
+        if (fTable.size() > 0)
+            printf(",\t");
+        for (const auto& it : fTable) {
+            if (c > 0)
+                printf(",\t");
+            printf("bargraph %d", c + 1);
+            c++;
+        }
+    }
+    
+    void display()
+    {
+        int c = 0;
+        if (fTable.size() > 0)
+            printf(",\t");
+        for (const auto& it : fTable) {
+            if (c > 0)
+                printf(",\t");
+            cout << *it.second;
+            c++;
+        }
+    }
+    
+};
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ VECTOR INTRINSICS
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+<<includeIntrinsic>>
+
+/********************END ARCHITECTURE SECTION (part 1/2)****************/
+
+/**************************BEGIN USER SECTION **************************/
+
+<<includeclass>>
+
+/***************************END USER SECTION ***************************/
+
+/*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
+
+dsp* DSP;
+
+std::list<GUI*> GUI::fGuiList;
+ztimedmap GUI::gTimedZoneMap;
+
+#define kFrames 512
+
+int main(int argc, char* argv[])
+{
+    FAUSTFLOAT nb_samples, sample_rate, buffer_size, start_at_sample;
+    
+    DSP = new mydsp();
+    
+    CMDUI* interface = new CMDUI(argc, argv);
+    DSP->buildUserInterface(interface);
+    
+    interface->addOption("-s", &start_at_sample, 0, 0.0, 100000000.0);
+    interface->addOption("-n", &nb_samples, 4096.0, 0.0, 100000000.0);
+    interface->addOption("-r", &sample_rate, 44100.0, 0.0, 192000.0);
+    interface->addOption("-bs", &buffer_size, kFrames, 0.0, kFrames * 16);
+    
+    if (DSP->getNumInputs() > 0) {
+        cerr << "no inputs allowed " << endl;
+        exit(1);
+    }
+    
+    // SR has to be read before DSP init
+    interface->process_one_init("-r");
+    
+    // init signal processor and the user interface values
+    DSP->init(sample_rate);
+    
+    // modify the UI values according to the command line options, after init
+    interface->process_init();
+    
+#ifdef SOUNDFILE
+    SoundUI soundinterface;
+    DSP->buildUserInterface(&soundinterface);
+#endif
+
+    DisplayUI disp;
+    DSP->buildUserInterface(&disp);
+    
+    // init signal processor and the user interface values
+    int nouts = DSP->getNumOutputs();
+    channels chan(max(kFrames, int(buffer_size)), nouts);
+    
+    // skip <start> samples
+    int start = int(start_at_sample);
+    while (start > kFrames) {
+        DSP->compute(kFrames, nullptr, chan.buffers());
+        start -= kFrames;
+    }
+    if (start > 0) {
+        DSP->compute(start, nullptr, chan.buffers());
+    }
+    // end skip
+    
+    // print channel headers
+    for (int c = 0; c < nouts; c++) {
+        if (c > 0)
+            printf(",\t");
+        printf("channel %d", c + 1);
+    }
+    disp.displayHeaders();
+    cout << endl;
+    
+    int nbsamples = int(nb_samples);
+    cout << setprecision(numeric_limits<FAUSTFLOAT>::max_digits10);
+    
+    // print by buffer
+    while (nbsamples > buffer_size) {
+        DSP->compute(buffer_size, 0, chan.buffers());
+        for (int i = 0; i < buffer_size; i++) {
+            for (int c = 0; c < nouts; c++) {
+                if (c > 0)
+                    printf(",\t");
+                cout << chan.buffers()[c][i];
+            }
+            disp.display();
+            cout << endl;
+        }
+        nbsamples -= buffer_size;
+    }
+    
+    // print remaining frames
+    if (nbsamples) {
+        DSP->compute(nbsamples, 0, chan.buffers());
+        for (int i = 0; i < nbsamples; i++) {
+            for (int c = 0; c < nouts; c++) {
+                if (c > 0)
+                    printf(",\t");
+                cout << chan.buffers()[c][i];
+            }
+            disp.display();
+            cout << endl;
+        }
+    }
+    
+    delete DSP;
+    return 0;
+}
+
+/******************** END cvsplot.cpp ****************/
+

cyfaust/resources/architecture/daisy/Makefile

@@ -0,0 +1,14 @@
+# Project Name
+TARGET = ex_faust
+
+# Sources
+CPP_SOURCES = ex_faust.cpp
+
+# Library Locations
+LIBDAISY_DIR ?= ../../../libdaisy
+DAISYSP_DIR ?= ../../../DaisySP
+
+# Core location, and generic Makefile.
+SYSTEM_FILES_DIR = $(LIBDAISY_DIR)/core
+include $(SYSTEM_FILES_DIR)/Makefile
+

cyfaust/resources/architecture/daisy/README.md

@@ -0,0 +1,50 @@
+# faust2daisy
+
+The **faust2daisy** tool compiles a Faust DSP program in a folder containing the C++ source code and a Makefile to compile it.  
+
+`faust2daisy [-patch] [-midi] [-nvoices <num>] [-sr <num>] [-bs <num>] [-source] [additional Faust options (-vec -vs 8...)] <file.dsp>`
+
+Here are the available options:
+
+- `-patch`: to compile for 4 ins/outs Patch (TODO)
+- `-pod`: to compile for 2 ins/outs Pod (knob[1,3])
+- `-midi`: to activate MIDI control`
+- `-nvoices <num>`: to produce a polyphonic self-contained DSP with <num> voices, ready to be used with MIDI (TODO)
+- `-sr <num>`: to specify sample rate (default 44100)
+- `-bs <num>`: to specify buffer size (default 16)
+- `-source`: to only create the source folder
+
+The generated folder has to be moved in the *DaisyExamples/DaisySP/examples* folder and compiled from there. 
+
+The current **faust2daisy** tool can only be used to program the [POD](https://www.electro-smith.com/daisy/pod). On this board, the 2 *switches* and 2 *knobs* can be connected to UI controllers using metadata:
+
+- `[switch:N]` (with N from 1 to 2) has to be used in a `button` or `checkbox` item to connect it to the POD switch number N.
+- `[knob:N]` (with N from 1 to 2) has to be used in a `vslider`, `hslider` or `nentry` item to connect it to the POD knob number N. The knob [0..1] range will be mapped to the slider/nentry [min..max] range.
+
+Other metadata:
+
+- `[scale:lin|log|exp]` metadata is implemented.
+
+## DSP examples
+
+Here is a simple example showing how oscillators can be controlled by physical items and MIDI messages:
+
+```
+import("stdfaust.lib");
+
+// UI controllers connected using metadata
+freq = hslider("freq [knob:1] [midi:ctrl 1] [scale:log]", 200, 50, 5000, 0.01);
+gain = hslider("gain [knob:2] [midi:ctrl 7]", 0.5, 0, 1, 0.01);
+gate = button("gate [switch:1]");
+check = checkbox("check [switch:2]");
+
+// DSP processor
+process = os.osc(freq) * gain * gate, os.sawtooth(freq) * gain * check;
+```
+
+## Architecture files
+
+Specific architecture files have been developed:
+
+- [faust/gui/DaisyControlUI.h](https://github.com/grame-cncm/faust/blob/master-dev/architecture/faust/gui/DaisyControlUI.h): to be used with the DSP `buildUserInterface` method to implement `button`, `checkbox`, `hslider`, `vslider` controllers, and interpret the specific metadata previously described
+- [faust/midi/daisy-midi.h](https://github.com/grame-cncm/faust/blob/master-dev/architecture/faust/midi/daisy-midi.h): implements a [midi_handler](https://github.com/grame-cncm/faust/blob/master-dev/architecture/faust/midi/midi.h) subclass to decode incoming MIDI events.