cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

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

@@ -0,0 +1,142 @@
+/************************** BEGIN CInterface.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 CINTERFACE_H
+#define CINTERFACE_H
+
+#ifndef FAUSTFLOAT
+#define FAUSTFLOAT float
+#endif
+
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+struct Soundfile;
+
+/*******************************************************************************
+ * UI, Meta and MemoryManager structures for C code.
+ ******************************************************************************/
+
+// -- widget's layouts
+
+typedef void (* openTabBoxFun) (void* ui_interface, const char* label);
+typedef void (* openHorizontalBoxFun) (void* ui_interface, const char* label);
+typedef void (* openVerticalBoxFun) (void* ui_interface, const char* label);
+typedef void (* closeBoxFun) (void* ui_interface);
+
+// -- active widgets
+
+typedef void (* addButtonFun) (void* ui_interface, const char* label, FAUSTFLOAT* zone);
+typedef void (* addCheckButtonFun) (void* ui_interface, const char* label, FAUSTFLOAT* zone);
+typedef void (* addVerticalSliderFun) (void* ui_interface, const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step);
+typedef void (* addHorizontalSliderFun) (void* ui_interface, const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step);
+typedef void (* addNumEntryFun) (void* ui_interface, const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step);
+
+// -- passive widgets
+
+typedef void (* addHorizontalBargraphFun) (void* ui_interface, const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max);
+typedef void (* addVerticalBargraphFun) (void* ui_interface, const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max);
+
+// -- soundfiles
+    
+typedef void (* addSoundfileFun) (void* ui_interface, const char* label, const char* url, struct Soundfile** sf_zone);
+
+typedef void (* declareFun) (void* ui_interface, FAUSTFLOAT* zone, const char* key, const char* value);
+
+typedef struct {
+
+    void* uiInterface;
+
+    openTabBoxFun openTabBox;
+    openHorizontalBoxFun openHorizontalBox;
+    openVerticalBoxFun openVerticalBox;
+    closeBoxFun closeBox;
+    addButtonFun addButton;
+    addCheckButtonFun addCheckButton;
+    addVerticalSliderFun addVerticalSlider;
+    addHorizontalSliderFun addHorizontalSlider;
+    addNumEntryFun addNumEntry;
+    addHorizontalBargraphFun addHorizontalBargraph;
+    addVerticalBargraphFun addVerticalBargraph;
+    addSoundfileFun addSoundfile;
+    declareFun declare;
+
+} UIGlue;
+
+typedef void (* metaDeclareFun) (void* ui_interface, const char* key, const char* value);
+
+typedef struct {
+
+    void* metaInterface;
+    
+    metaDeclareFun declare;
+
+} MetaGlue;
+
+/***************************************
+ *  Interface for the DSP object
+ ***************************************/
+
+typedef char dsp_imp;
+    
+typedef dsp_imp* (* newDspFun) ();
+typedef void (* destroyDspFun) (dsp_imp* dsp);
+typedef int (* getNumInputsFun) (dsp_imp* dsp);
+typedef int (* getNumOutputsFun) (dsp_imp* dsp);
+typedef void (* buildUserInterfaceFun) (dsp_imp* dsp, UIGlue* ui);
+typedef int (* getSampleRateFun) (dsp_imp* dsp);
+typedef void (* initFun) (dsp_imp* dsp, int sample_rate);
+typedef void (* classInitFun) (int sample_rate);
+typedef void (* instanceInitFun) (dsp_imp* dsp, int sample_rate);
+typedef void (* instanceConstantsFun) (dsp_imp* dsp, int sample_rate);
+typedef void (* instanceResetUserInterfaceFun) (dsp_imp* dsp);
+typedef void (* instanceClearFun) (dsp_imp* dsp);
+typedef void (* computeFun) (dsp_imp* dsp, int len, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs);
+typedef void (* metadataFun) (MetaGlue* meta);
+    
+/***************************************
+ * DSP memory manager functions
+ ***************************************/
+
+typedef void* (* allocateFun) (void* manager_interface, size_t size);
+typedef void (* destroyFun) (void* manager_interface, void* ptr);
+
+typedef struct {
+    
+    void* managerInterface;
+    
+    allocateFun allocate;
+    destroyFun destroy;
+    
+} MemoryManagerGlue;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/**************************  END  CInterface.h **************************/

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

@@ -0,0 +1,197 @@
+/************************** BEGIN ControlSequenceUI.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 CONTROL_SEQUENCE_UI_H
+#define CONTROL_SEQUENCE_UI_H
+
+#include <vector>
+#include <sstream>
+#include <fstream>
+#include <assert.h>
+
+#include "faust/gui/MapUI.h"
+
+struct TSMessage {
+    uint64_t    fDateSample;
+    std::string fPath;
+    FAUSTFLOAT  fValue;
+    
+    TSMessage(uint64_t ds, const std::string& path, FAUSTFLOAT value)
+    :fDateSample(ds), fPath(path), fValue(value)
+    {}
+};
+
+/*
+ Allows to process a sequence of time-stamped messages.
+ */
+class ControlSequenceUI : public MapUI {
+    
+    protected:
+    
+        std::vector<TSMessage> fSequence;
+        uint64_t               fCurSample;
+        int                    fEvent;
+    
+        void processMessage(const TSMessage& message)
+        {
+            setParamValue(message.fPath, message.fValue);
+        }
+    
+    public:
+    
+        ControlSequenceUI(const std::vector<TSMessage>& sequence):fSequence(sequence), fCurSample(0), fEvent(0) {}
+        virtual ~ControlSequenceUI() {}
+       
+        void process(uint64_t start_sample, uint64_t end_sample)
+        {
+            if (fSequence.size() == 0) return;
+            
+            // Restart from begining if needed
+            if (start_sample < fCurSample) {
+                fCurSample = 0;
+                fEvent = 0;
+            }
+            
+            // Move until start of range
+            while (fEvent < fSequence.size() && fSequence[fEvent].fDateSample < start_sample) {
+                fEvent++;
+            }
+            
+            // Process all messages in [start_sample, end_sample] range
+            while (fEvent < fSequence.size() && fSequence[fEvent].fDateSample <= end_sample) {
+                processMessage(fSequence[fEvent]);
+                fEvent++;
+            }
+            
+            // Keep last date
+            fCurSample = fSequence[fEvent].fDateSample;
+        }
+    
+        void display()
+        {
+            for (const auto& it : fSequence) {
+                std::cout << "fDateSample " << it.fDateSample << " fPath " << it.fPath << " fValue " << it.fValue << std::endl;
+            }
+        }
+    
+        void getRange(uint64_t& start_sample, uint64_t& end_sample)
+        {
+            if (fSequence.size() > 0) {
+                start_sample = fSequence[0].fDateSample;
+                end_sample = fSequence[fSequence.size()-1].fDateSample;
+            } else {
+                start_sample = end_sample = 0;
+            }
+        }
+        
+};
+
+/*
+ Read a sequence of messages of type:
+ 
+ e45377aa.206162f1 /karplus/gate f 1.000000
+ e45377aa.360afa2e /karplus/gate f 0.000000
+ e45377ab.0a40639d /karplus/params/freq f 267.850006
+ e45377ab.1f47f993 /karplus/params/freq f 286.850006
+ e45377ab.29c88616 /karplus/params/freq f 296.350006
+ e45377ab.34370cdc /karplus/params/freq f 305.850006
+ 
+ where a e451f81c.2be22e5d date is a timestamp in sec.frac format coded in hexadecimal.
+ 
+ To be used with ControlSequenceUI class.
+ */
+
+struct OSCSequenceReader {
+    
+    static uint64_t readDate(const std::string& date, int sample_rate)
+    {
+        std::stringstream tokenizer(date);
+        
+        std::string sec, frac;
+        getline(tokenizer, sec, '.');
+        getline(tokenizer, frac, '.');
+        
+        std::istringstream sec_reader("0x" + sec);
+        std::istringstream frac_reader("0x" + frac);
+        uint32_t sec_t, frac_t;
+        sec_reader >> std::hex >> sec_t;
+        frac_reader >> std::hex >> frac_t;
+        
+        return uint64_t(sample_rate * (double(sec_t) + (double(frac_t)/std::pow(2,32))));
+    }
+    
+    /**
+     * Read the file containing timestamped messages.
+     *
+     * @param filename - the filename path
+     * @param sample_rate - the sampling rate, needed to convert dates in seconds into dates in frames
+     *
+     * @return a vector of timestamped messages [path, value]
+     */
+    static std::vector<TSMessage> read(const std::string& filename, int sample_rate)
+    {
+        std::vector<TSMessage> res;
+        std::ifstream in_file(filename);
+        bool first_date = true;
+        uint64_t first_date_sample;
+        
+        if (in_file.is_open()) {
+            std::string line;
+            while (getline(in_file, line)) {
+                std::istringstream line_reader(line);
+                std::string date, path, type;
+                uint32_t sec, frac;
+                
+                line_reader >> date;
+                line_reader >> path;
+                line_reader >> type;
+                
+                // Read date, relative to first one
+                uint64_t date_sample = readDate(date, sample_rate);
+                if (first_date) {
+                    first_date_sample = date_sample;
+                    first_date = false;
+                }
+                date_sample -= first_date_sample;
+                
+                if (type == "i") {
+                    int value_int;
+                    line_reader >> value_int;
+                    res.push_back(TSMessage(date_sample, path, FAUSTFLOAT(value_int)));
+                } else if (type == "f") {
+                    FAUSTFLOAT value_float;
+                    line_reader >> value_float;
+                    res.push_back(TSMessage(date_sample, path, value_float));
+                }
+            }
+            in_file.close();
+        }
+        
+        return res;
+    }
+};
+
+#endif
+/**************************  END ControlSequenceUI.h **************************/

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

@@ -0,0 +1,137 @@
+/************************** BEGIN ControlUI.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 CONTROL_UI_H
+#define CONTROL_UI_H
+
+#include <jack/midiport.h>
+#include <vector>
+#include <assert.h>
+
+#include "faust/gui/DecoratorUI.h"
+
+class ControlUI : public UI {
+
+    protected:
+    
+        std::vector<FAUSTFLOAT*> fControlIn;
+        std::vector<FAUSTFLOAT*> fControlOut;
+    
+        // -- widget's layouts
+    
+        void openTabBox(const char* label) {}
+        void openHorizontalBox(const char* label) {}
+        void openVerticalBox(const char* label) {}
+        void closeBox() {}
+
+        // -- active widgets
+
+        void addButton(const char* label, FAUSTFLOAT* zone) { fControlIn.push_back(zone); }
+        void addCheckButton(const char* label, FAUSTFLOAT* zone) { fControlIn.push_back(zone); }
+        void addVerticalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) { fControlIn.push_back(zone); };
+        void addHorizontalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) { fControlIn.push_back(zone); };
+        void addNumEntry(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) { fControlIn.push_back(zone); };
+
+        // -- passive widgets
+
+        void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) { fControlOut.push_back(zone); };
+        void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) { fControlOut.push_back(zone); };
+    
+        // No used
+        void addSoundfile(const char* label, const char* filename, Soundfile** sf_zone) {}
+        void declare(FAUSTFLOAT* zone, const char* key, const char* val) {}
+    
+    public:
+    
+        ControlUI() {}
+        virtual ~ControlUI() {}
+       
+        void encodeControl(float* control_buffer, unsigned int frames)
+        { 
+            assert(fControlOut.size() <= frames);
+            
+            for (size_t i = 0; i < fControlOut.size(); i++) {
+                control_buffer[i] = *fControlOut[i];
+            }
+        }
+        
+        void decodeControl(float* control_buffer, unsigned int frames)
+        {
+            assert(fControlIn.size() <= frames);
+            
+            for (size_t i = 0; i < fControlIn.size(); i++) {
+               *fControlIn[i] = control_buffer[i];
+            }
+        }
+        
+        void encodeMidiControl(void* midi_control_buffer, unsigned int frames)
+        { 
+            assert(fControlOut.size() <= frames);
+            jack_midi_reset_buffer(midi_control_buffer);
+          
+            for (size_t i = 0; i < fControlOut.size(); i++) {
+                jack_midi_data_t* buffer = jack_midi_event_reserve(midi_control_buffer, i, 4);
+                assert(buffer);
+                *((float*)buffer) = *fControlOut[i];
+            }
+        }
+    
+        static void encodeMidiControl(void* midi_control_buffer, float* control_buffer, int count)
+        {
+            jack_midi_reset_buffer(midi_control_buffer);
+            
+            for (size_t i = 0; i < count; i++) {
+                jack_midi_data_t* buffer = jack_midi_event_reserve(midi_control_buffer, i, 4);
+                assert(buffer);
+                *((float*)buffer) = control_buffer[i];
+            }
+        }
+        
+        void decodeMidiControl(void* midi_control_buffer, unsigned int frames)
+        {
+            assert(jack_midi_get_event_count(midi_control_buffer) <= frames);
+            
+            for (int i = 0; i < jack_midi_get_event_count(midi_control_buffer); i++) {
+                jack_midi_event_t in_event;
+                jack_midi_event_get(&in_event, midi_control_buffer, i);
+                *fControlIn[i] = *((float*)in_event.buffer);
+            }
+        }
+        
+        static void decodeMidiControl(void* midi_control_buffer, float* control_buffer, int count)
+        {
+            assert(jack_midi_get_event_count(midi_control_buffer) <= count);
+            
+            for (int i = 0; i < jack_midi_get_event_count(midi_control_buffer); i++) {
+                jack_midi_event_t in_event;
+                jack_midi_event_get(&in_event, midi_control_buffer, i);
+                control_buffer[i] = *((float*)(in_event.buffer));
+            }
+        }
+        
+};
+
+#endif
+/**************************  END  ControlUI.h **************************/