cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/teensy/teensy.cpp

@@ -0,0 +1,214 @@
+/************************************************************************
+ 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 ARCHITECTURE SECTION (part 1/2)****************/
+
+/************************************************************************
+ FAUST Architecture File
+ Copyright (C) 2019-2020 GRAME, Centre National de Creation Musicale &
+ Aalborg University (Copenhagen, Denmark)
+ ---------------------------------------------------------------------
+ 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 <string.h> // for memset
+
+#include "teensy.h"
+
+// IMPORTANT: in order for MapUI to work, the teensy linker must be g++
+#include "faust/gui/MapUI.h"
+#include "faust/gui/meta.h"
+#include "faust/dsp/dsp.h"
+
+// MIDI support
+#if MIDICTRL
+#include "faust/gui/MidiUI.h"
+#include "faust/midi/teensy-midi.h"
+#endif
+
+// for polyphonic synths
+#ifdef NVOICES
+#include "faust/dsp/poly-dsp.h"
+#endif
+
+// 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)
+
+/******************************************************************************
+ *******************************************************************************
+ 
+ VECTOR INTRINSICS
+ 
+ *******************************************************************************
+ *******************************************************************************/
+
+<<includeIntrinsic>>
+
+/********************END ARCHITECTURE SECTION (part 1/2)****************/
+
+/**************************BEGIN USER SECTION **************************/
+
+<<includeclass>>
+
+/***************************END USER SECTION ***************************/
+
+/*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
+
+#define MULT_16 32767
+#define DIV_16 0.0000305185
+
+// Not needed
+// unsigned __exidx_start;
+// unsigned __exidx_end;
+
+#if MIDICTRL
+std::list<GUI*> GUI::fGuiList;
+ztimedmap GUI::gTimedZoneMap;
+#endif
+
+AudioFaust::AudioFaust() : AudioStream(FAUST_INPUTS, new audio_block_t*[FAUST_INPUTS])
+{
+#ifdef NVOICES
+    int nvoices = NVOICES;
+    fDSP = new mydsp_poly(new mydsp(), nvoices, true, true);
+#else
+    fDSP = new mydsp();
+#endif
+    
+    fDSP->init(AUDIO_SAMPLE_RATE_EXACT);
+    
+    fUI = new MapUI();
+    fDSP->buildUserInterface(fUI);
+    
+    // allocating Faust inputs
+    if (fDSP->getNumInputs() > 0) {
+        fInChannel = new float*[fDSP->getNumInputs()];
+        for (int i = 0; i < fDSP->getNumInputs(); i++) {
+            fInChannel[i] = new float[AUDIO_BLOCK_SAMPLES];
+        }
+    } else {
+        fInChannel = NULL;
+    }
+    
+    // allocating Faust outputs
+    if (fDSP->getNumOutputs() > 0) {
+        fOutChannel = new float*[fDSP->getNumOutputs()];
+        for (int i = 0; i < fDSP->getNumOutputs(); i++) {
+            fOutChannel[i] = new float[AUDIO_BLOCK_SAMPLES];
+        }
+    } else {
+        fOutChannel = NULL;
+    }
+    
+#if MIDICTRL
+    fMIDIHandler = new teensy_midi();
+    fMIDIInterface = new MidiUI(fMIDIHandler);
+    fDSP->buildUserInterface(fMIDIInterface);
+    fMIDIInterface->run();
+#endif
+}
+
+AudioFaust::~AudioFaust()
+{
+    delete fDSP;
+    delete fUI;
+    for (int i = 0; i < fDSP->getNumInputs(); i++) {
+        delete[] fInChannel[i];
+    }
+    delete [] fInChannel;
+    for (int i = 0; i < fDSP->getNumOutputs(); i++) {
+        delete[] fOutChannel[i];
+    }
+    delete [] fOutChannel;
+#if MIDICTRL
+    delete fMIDIInterface;
+    delete fMIDIHandler;
+#endif
+}
+
+template <int INPUTS, int OUTPUTS>
+void AudioFaust::updateImp(void)
+{
+#if MIDICTRL
+    // Process the MIDI messages received by the Teensy
+    fMIDIHandler->processMidi();
+    // Synchronize all GUI controllers
+    GUI::updateAllGuis();
+#endif
+    
+    if (INPUTS > 0) {
+        audio_block_t* inBlock[INPUTS];
+        for (int channel = 0; channel < INPUTS; channel++) {
+            inBlock[channel] = receiveReadOnly(channel);
+            if (inBlock[channel]) {
+                for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) {
+                    int16_t val = inBlock[channel]->data[i];
+                    fInChannel[channel][i] = val*DIV_16;
+                }
+                release(inBlock[channel]);
+            } else {
+                memset(fInChannel[channel], 0, AUDIO_BLOCK_SAMPLES * sizeof(float));
+            }
+        }
+    }
+    
+    fDSP->compute(AUDIO_BLOCK_SAMPLES, fInChannel, fOutChannel);
+    
+    audio_block_t* outBlock[OUTPUTS];
+    for (int channel = 0; channel < OUTPUTS; channel++) {
+        outBlock[channel] = allocate();
+        if (outBlock[channel]) {
+            for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) {
+                int16_t val = fOutChannel[channel][i]*MULT_16;
+                outBlock[channel]->data[i] = val;
+            }
+            transmit(outBlock[channel], channel);
+            release(outBlock[channel]);
+        }
+    }
+}
+
+void AudioFaust::update(void) { updateImp<FAUST_INPUTS, FAUST_OUTPUTS>(); }
+
+void AudioFaust::setParamValue(const std::string& path, float value)
+{
+    fUI->setParamValue(path, value);
+}
+
+float AudioFaust::getParamValue(const std::string& path)
+{
+    return fUI->getParamValue(path);
+}
+
+/********************END ARCHITECTURE SECTION (part 2/2)****************/

cyfaust/resources/architecture/teensy/teensy.h

@@ -0,0 +1,71 @@
+/************************************************************************
+ FAUST Architecture File
+ Copyright (C) 2019-2020 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 faust_teensy_h_
+#define faust_teensy_h_
+
+#include <string>
+
+#include "Arduino.h"
+#include "AudioStream.h"
+#include "Audio.h"
+
+#define fprintf(X, Y, Z) Serial.printf(Y, Z)
+
+class dsp;
+class MapUI;
+
+#if MIDICTRL
+class MidiUI;
+class teensy_midi;
+#endif
+
+class AudioFaust : public AudioStream
+{
+    public:
+    
+        AudioFaust();
+        ~AudioFaust();
+    
+        virtual void update(void);
+    
+        void setParamValue(const std::string& path, float value);
+        float getParamValue(const std::string& path);
+    
+    private:
+    
+        template <int INPUTS, int OUTPUTS>
+        void updateImp(void);
+    
+        float** fInChannel;
+        float** fOutChannel;
+        MapUI* fUI;
+    #if MIDICTRL
+        teensy_midi* fMIDIHandler;
+        MidiUI* fMIDIInterface;
+    #endif
+        dsp* fDSP;
+};
+
+#endif

cyfaust/resources/architecture/thread.h

@@ -0,0 +1,373 @@
+/************************** BEGIN thread.h **************************/
+/************************************************************************
+ FAUST Architecture File
+ Copyright (C) 2020 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 <stdlib.h>
+#include <assert.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <semaphore.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <math.h>
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifdef __ICC
+#define INLINE __forceinline
+#else
+#define INLINE inline
+#endif
+
+// Globals
+
+#define THREAD_POOL_SIZE 16
+#define JACK_SCHED_POLICY SCHED_FIFO
+
+/* use 512KB stack per thread - the default is way too high to be feasible
+ * with mlockall() on many systems */
+#define THREAD_STACK 524288
+
+typedef void* (ThreadHandler) (void* arg);
+
+static int GetPID()
+{
+#ifdef WIN32
+    return  _getpid();
+#else
+    return getpid();
+#endif
+}
+
+#ifdef __APPLE__
+#include <CoreServices/../Frameworks/CarbonCore.framework/Headers/MacTypes.h>
+#include <mach/thread_policy.h>
+#include <mach/thread_act.h>
+
+#include <mach/thread_policy.h>
+#include <mach/thread_act.h>
+
+#define THREAD_SET_PRIORITY         0
+#define THREAD_SCHEDULED_PRIORITY   1
+
+static UInt32 GetThreadPriority(pthread_t thread, int inWhichPriority);
+
+// returns the thread's priority as it was last set by the API
+static UInt32 GetThreadSetPriority(pthread_t thread)
+{
+    return GetThreadPriority(thread, THREAD_SET_PRIORITY);
+}
+
+// returns the thread's priority as it was last scheduled by the Kernel
+static UInt32 GetThreadScheduledPriority(pthread_t thread)
+{
+    return GetThreadPriority(thread, THREAD_SCHEDULED_PRIORITY);
+}
+
+static int SetThreadToPriority(pthread_t thread, UInt32 inPriority, Boolean inIsFixed, UInt64 period, UInt64 computation, UInt64 constraint)
+{
+    if (inPriority == 96) {
+        // REAL-TIME / TIME-CONSTRAINT THREAD
+        thread_time_constraint_policy_data_t theTCPolicy;
+        theTCPolicy.period = period;
+        theTCPolicy.computation = computation;
+        theTCPolicy.constraint = constraint;
+        theTCPolicy.preemptible = true;
+        kern_return_t res = thread_policy_set(pthread_mach_thread_np(thread), THREAD_TIME_CONSTRAINT_POLICY, (thread_policy_t)&theTCPolicy, THREAD_TIME_CONSTRAINT_POLICY_COUNT);
+        return (res == KERN_SUCCESS) ? 0 : -1;
+    } else {
+        // OTHER THREADS
+        thread_extended_policy_data_t theFixedPolicy;
+        thread_precedence_policy_data_t thePrecedencePolicy;
+        SInt32 relativePriority;
+        
+        // [1] SET FIXED / NOT FIXED
+        theFixedPolicy.timeshare = !inIsFixed;
+        thread_policy_set(pthread_mach_thread_np(thread), THREAD_EXTENDED_POLICY, (thread_policy_t)&theFixedPolicy, THREAD_EXTENDED_POLICY_COUNT);
+        
+        // [2] SET PRECEDENCE
+        // N.B.: We expect that if thread A created thread B, and the program wishes to change
+        // the priority of thread B, then the call to change the priority of thread B must be
+        // made by thread A.
+        // This assumption allows us to use pthread_self() to correctly calculate the priority
+        // of the feeder thread (since precedency policy's importance is relative to the
+        // spawning thread's priority.)
+        relativePriority = inPriority - GetThreadSetPriority(pthread_self());
+        
+        thePrecedencePolicy.importance = relativePriority;
+        kern_return_t res = thread_policy_set(pthread_mach_thread_np(thread), THREAD_PRECEDENCE_POLICY, (thread_policy_t)&thePrecedencePolicy, THREAD_PRECEDENCE_POLICY_COUNT);
+        return (res == KERN_SUCCESS) ? 0 : -1;
+    }
+}
+
+static UInt32 GetThreadPriority(pthread_t thread, int inWhichPriority)
+{
+    thread_basic_info_data_t threadInfo;
+    policy_info_data_t thePolicyInfo;
+    unsigned int count;
+    
+    // get basic info
+    count = THREAD_BASIC_INFO_COUNT;
+    thread_info(pthread_mach_thread_np(thread), THREAD_BASIC_INFO, (thread_info_t)&threadInfo, &count);
+    
+    switch (threadInfo.policy) {
+        case POLICY_TIMESHARE:
+            count = POLICY_TIMESHARE_INFO_COUNT;
+            thread_info(pthread_mach_thread_np(thread), THREAD_SCHED_TIMESHARE_INFO, (thread_info_t)&(thePolicyInfo.ts), &count);
+            if (inWhichPriority == THREAD_SCHEDULED_PRIORITY) {
+                return thePolicyInfo.ts.cur_priority;
+            } else {
+                return thePolicyInfo.ts.base_priority;
+            }
+            break;
+            
+        case POLICY_FIFO:
+            count = POLICY_FIFO_INFO_COUNT;
+            thread_info(pthread_mach_thread_np(thread), THREAD_SCHED_FIFO_INFO, (thread_info_t)&(thePolicyInfo.fifo), &count);
+            if ((thePolicyInfo.fifo.depressed) && (inWhichPriority == THREAD_SCHEDULED_PRIORITY)) {
+                return thePolicyInfo.fifo.depress_priority;
+            }
+            return thePolicyInfo.fifo.base_priority;
+            break;
+            
+        case POLICY_RR:
+            count = POLICY_RR_INFO_COUNT;
+            thread_info(pthread_mach_thread_np(thread), THREAD_SCHED_RR_INFO, (thread_info_t)&(thePolicyInfo.rr), &count);
+            if ((thePolicyInfo.rr.depressed) && (inWhichPriority == THREAD_SCHEDULED_PRIORITY)) {
+                return thePolicyInfo.rr.depress_priority;
+            }
+            return thePolicyInfo.rr.base_priority;
+            break;
+    }
+    
+    return 0;
+}
+
+static int GetParams(pthread_t thread, UInt64* period, UInt64* computation, UInt64* constraint)
+{
+    thread_time_constraint_policy_data_t theTCPolicy;
+    mach_msg_type_number_t count = THREAD_TIME_CONSTRAINT_POLICY_COUNT;
+    boolean_t get_default = false;
+    
+    kern_return_t res = thread_policy_get(pthread_mach_thread_np(thread),
+                                          THREAD_TIME_CONSTRAINT_POLICY,
+                                          (thread_policy_t)&theTCPolicy,
+                                          &count,
+                                          &get_default);
+    if (res == KERN_SUCCESS) {
+        *period = theTCPolicy.period;
+        *computation = theTCPolicy.computation;
+        *constraint = theTCPolicy.constraint;
+        return 0;
+    } else {
+        return -1;
+    }
+}
+
+static UInt64 period = 0;
+static UInt64 computation = 0;
+static UInt64 constraint = 0;
+
+INLINE void GetRealTime()
+{
+    if (period == 0) {
+        GetParams(pthread_self(), &period, &computation, &constraint);
+    }
+}
+
+INLINE void SetRealTime()
+{
+    SetThreadToPriority(pthread_self(), 96, true, period, computation, constraint);
+}
+
+#endif
+
+struct RunThread {
+
+    pthread_t fThread;
+    sem_t* fSemaphore;
+    char fName[128];
+    bool fRealTime;
+
+    #ifdef __APPLE__
+    
+    void Cancel()
+    {
+        mach_port_t machThread = pthread_mach_thread_np(fThread);
+        thread_terminate(machThread);
+    }
+    
+    void Join()
+    {
+        sem_post(fSemaphore);
+        pthread_join(fThread, NULL);
+    }
+
+
+    #endif
+
+    #ifdef __linux__
+
+    void Cancel()
+    {
+        pthread_cancel(fThread);
+        pthread_join(fThread, NULL);
+    }
+    
+    void Join()
+    {
+        sem_post(fSemaphore);
+        pthread_join(fThread, NULL);
+    }
+
+    #endif
+    
+    RunThread()
+    {
+        sprintf(fName, "faust_sem_%d_%p", GetPID(), this);
+        if ((fSemaphore = sem_open(fName, O_CREAT, 0777, 0)) == (sem_t*)SEM_FAILED) {
+            std::cerr << "Allocate: can't check in named semaphore name = " <<fName << " " << strerror(errno) << std::endl;
+            throw std::bad_alloc();
+        }
+    }
+    
+    ~RunThread()
+    {
+        sem_unlink(fName);
+        sem_close(fSemaphore);
+    }
+    
+    void Wait()
+    {
+        while (sem_wait(fSemaphore) != 0) {}
+    }
+    
+    void Signal()
+    {
+         sem_post(fSemaphore);
+    }
+ 
+    int Start(bool realtime, ThreadHandler fun, void* arg)
+    {
+        pthread_attr_t attributes;
+        struct sched_param rt_param;
+        pthread_attr_init(&attributes);
+        
+        int priority = 70; // TODO
+        int res;
+        
+        if (realtime) {
+            fRealTime = true;
+        }else {
+            fRealTime = getenv("OMP_REALTIME") ? strtol(getenv("OMP_REALTIME"), NULL, 10) : true;
+        }
+                               
+        if ((res = pthread_attr_setdetachstate(&attributes, PTHREAD_CREATE_JOINABLE))) {
+            printf("Cannot request joinable thread creation for real-time thread res = %d err = %s\n", res, strerror(errno));
+            return -1;
+        }
+
+        if ((res = pthread_attr_setscope(&attributes, PTHREAD_SCOPE_SYSTEM))) {
+            printf("Cannot set scheduling scope for real-time thread res = %d err = %s\n", res, strerror(errno));
+            return -1;
+        }
+
+        if (realtime) {
+            
+            if ((res = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED))) {
+                printf("Cannot request explicit scheduling for RT thread res = %d err = %s\n", res, strerror(errno));
+                return -1;
+            }
+        
+            if ((res = pthread_attr_setschedpolicy(&attributes, JACK_SCHED_POLICY))) {
+                printf("Cannot set RR scheduling class for RT thread res = %d err = %s\n", res, strerror(errno));
+                return -1;
+            }
+            
+            memset(&rt_param, 0, sizeof(rt_param));
+            rt_param.sched_priority = priority;
+
+            if ((res = pthread_attr_setschedparam(&attributes, &rt_param))) {
+                printf("Cannot set scheduling priority for RT thread res = %d err = %s\n", res, strerror(errno));
+                return -1;
+            }
+
+        } else {
+            
+            if ((res = pthread_attr_setinheritsched(&attributes, PTHREAD_INHERIT_SCHED))) {
+                printf("Cannot request explicit scheduling for RT thread res = %d err = %s\n", res, strerror(errno));
+                return -1;
+            }
+        }
+     
+        if ((res = pthread_attr_setstacksize(&attributes, THREAD_STACK))) {
+            printf("Cannot set thread stack size res = %d err = %s\n", res, strerror(errno));
+            return -1;
+        }
+        
+        if ((res = pthread_create(&fThread, &attributes, fun, arg))) {
+            printf("Cannot create thread res = %d err = %s\n", res, strerror(errno));
+            return -1;
+        }
+
+        pthread_attr_destroy(&attributes);
+        return 0;
+    }
+
+    void Stop()
+    {
+        Cancel();
+    }
+    
+};
+
+char* load_program_source(const char* filename)
+{
+    struct stat statbuf;
+    FILE* fh;
+    char* source;
+
+    fh = fopen(filename, "r");
+    if (fh == 0) return 0;
+
+    stat(filename, &statbuf);
+    source = (char*)malloc(statbuf.st_size + 1);
+    fread(source, statbuf.st_size, 1, fh);
+    source[statbuf.st_size] = '\0';
+
+    return source;
+}
+
+#ifdef __cplusplus
+}
+#endif
+/************************** END thread.h **************************/