cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/faust/dsp/dsp-tools.h

@@ -0,0 +1,229 @@
+/************************** BEGIN dsp-tools.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 __dsp_tools__
+#define __dsp_tools__
+
+#include <assert.h>
+#include <string.h>
+
+#ifndef FAUSTFLOAT
+#define FAUSTFLOAT float
+#endif
+
+class Deinterleaver
+{
+    
+    private:
+    
+        int fNumFrames;
+        int fNumInputs;
+        int fNumOutputs;
+        
+        FAUSTFLOAT* fInput;
+        FAUSTFLOAT* fOutputs[256];
+        
+    public:
+        
+        Deinterleaver(int numFrames, int numInputs, int numOutputs)
+        {
+            fNumFrames = numFrames;
+            fNumInputs = numInputs;
+            fNumOutputs = std::max<int>(numInputs, numOutputs);
+            
+            // allocate interleaved input channel
+            fInput = new FAUSTFLOAT[fNumFrames * fNumInputs];
+            
+            // allocate separate output channels
+            for (int i = 0; i < fNumOutputs; i++) {
+                fOutputs[i] = new FAUSTFLOAT[fNumFrames];
+            }
+        }
+        
+        ~Deinterleaver()
+        {
+            // free interleaved input channel
+            delete [] fInput;
+            
+            // free separate output channels
+            for (int i = 0; i < fNumOutputs; i++) {
+                delete [] fOutputs[i];
+            }
+        }
+        
+        FAUSTFLOAT* input() { return fInput; }
+        
+        FAUSTFLOAT** outputs() { return fOutputs; }
+        
+        void deinterleave()
+        {
+            for (int s = 0; s < fNumFrames; s++) {
+                for (int c = 0; c < fNumInputs; c++) {
+                    fOutputs[c][s] = fInput[c + s * fNumInputs];
+                }
+            }
+        }
+};
+
+class Interleaver
+{
+    
+    private:
+        
+        int fNumFrames;
+        int fNumInputs;
+        int fNumOutputs;
+    
+        FAUSTFLOAT* fInputs[256];
+        FAUSTFLOAT* fOutput;
+        
+    public:
+        
+        Interleaver(int numFrames, int numInputs, int numOutputs)
+        {
+            fNumFrames = numFrames;
+            fNumInputs 	= std::max(numInputs, numOutputs);
+            fNumOutputs = numOutputs;
+            
+            // allocate separate input channels
+            for (int i = 0; i < fNumInputs; i++) {
+                fInputs[i] = new FAUSTFLOAT[fNumFrames];
+            }
+            
+            // allocate interleaved output channel
+            fOutput = new FAUSTFLOAT[fNumFrames * fNumOutputs];
+        }
+        
+        ~Interleaver()
+        {
+            // free separate input channels
+            for (int i = 0; i < fNumInputs; i++) {
+                delete [] fInputs[i];
+            }
+            
+            // free interleaved output channel
+            delete [] fOutput;
+        }
+        
+        FAUSTFLOAT** inputs() { return fInputs; }
+        
+        FAUSTFLOAT* output() { return fOutput; }
+        
+        void interleave()
+        {
+            for (int s = 0; s < fNumFrames; s++) {
+                for (int c = 0; c < fNumOutputs; c++) {
+                    fOutput[c + s * fNumOutputs] = fInputs[c][s];
+                }
+            }
+        }
+};
+
+//=============================================================================
+// An AudioChannels is a group of non-interleaved buffers that knows how to read
+// from or write to an interleaved buffer. The interleaved buffer may have a
+// different number of channels than the AudioChannels internal channels.
+//=============================================================================
+
+class AudioChannels
+{
+    
+    protected:
+        
+        const unsigned int fNumFrames;
+        const unsigned int fNumChannels;
+        FAUSTFLOAT** fChannels;
+        
+    public:
+        
+        AudioChannels(int nframes, int nchannels) : fNumFrames(nframes), fNumChannels(nchannels)
+        {
+            fChannels = new FAUSTFLOAT*[nchannels];
+            
+            // allocate audio channels
+            for (unsigned int i = 0; i < fNumChannels; i++) {
+                fChannels[i] = new FAUSTFLOAT[fNumFrames];
+                memset(fChannels[i], 0, sizeof(FAUSTFLOAT) * fNumFrames);
+            }
+        }
+        
+        virtual ~AudioChannels()
+        {
+            // free separate input channels
+            for (int i = 0; i < fNumChannels; i++) {
+                delete[] fChannels[i];
+            }
+            delete[] fChannels;
+        }
+        
+        //---------------------------------------------------------------------------------------
+        // interleavedRead: read, from the interleaved buffer <inbuffer>, <length> frames on
+        // <inchannels> channels. The samples are written to the <fNumChannels> internal
+        // <fChannels>.
+        void interleavedRead(float* inbuffer, unsigned int length, unsigned int inchannels)
+        {
+            assert(length <= fNumFrames);
+            unsigned int C = std::min<unsigned int>(inchannels, fNumChannels);
+            unsigned int F = std::min<unsigned int>(length, fNumFrames);
+            
+            for (unsigned int f = 0; f < F; f++) {
+                unsigned int p = f * inchannels;
+                for (unsigned int c = 0; c < C; c++) {
+                    fChannels[c][f] = inbuffer[p++];
+                }
+                for (unsigned int c = C; c < fNumChannels; c++) {
+                    fChannels[c][f] = 0;
+                }
+            }
+        }
+        
+        //----------------------------------------------------------------------------------------
+        // interleavedWrite: write to the interleaved buffer <inbuffer>, <length> frames on
+        // <outchannels> channels. The samples are read from <fNumChannels> internal
+        // <fChannels>.
+        void interleavedWrite(float* outbuffer, unsigned int length, unsigned int outchannels)
+        {
+            assert(length <= fNumFrames);
+            unsigned int C = std::min<unsigned int>(outchannels, fNumChannels);
+            unsigned int F = std::min<unsigned int>(length, fNumFrames);
+            
+            for (unsigned int f = 0; f < F; f++) {
+                unsigned int p = f * outchannels;
+                for (unsigned int c = 0; c < C; c++) {
+                    outbuffer[p++] = fChannels[c][f];
+                }
+                for (unsigned int c = C; c < outchannels; c++) {
+                    outbuffer[p++] = 0;
+                }
+            }
+        }
+        
+        //----------------------------------------------------------------------------------------
+        // buffers: the internal buffers ready to use in the compute() method of a Faust dsp
+        
+        FAUSTFLOAT** buffers() { return fChannels; }
+};
+
+#endif
+/************************** END dsp-tools.h **************************/

cyfaust/resources/architecture/faust/dsp/dsp.h

@@ -0,0 +1,321 @@
+/************************** BEGIN dsp.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 __dsp__
+#define __dsp__
+
+#include <string>
+#include <vector>
+#include <cstdint>
+
+#include "faust/export.h"
+
+#ifndef FAUSTFLOAT
+#define FAUSTFLOAT float
+#endif
+
+struct FAUST_API UI;
+struct FAUST_API Meta;
+
+/**
+ * DSP memory manager.
+ */
+
+struct FAUST_API dsp_memory_manager {
+    
+    virtual ~dsp_memory_manager() {}
+    
+    /**
+     * Inform the Memory Manager with the number of expected memory zones.
+     * @param count - the number of expected memory zones
+     */
+    virtual void begin(size_t /*count*/) {}
+    
+    /**
+     * Give the Memory Manager information on a given memory zone.
+     * @param size - the size in bytes of the memory zone
+     * @param reads - the number of Read access to the zone used to compute one frame
+     * @param writes - the number of Write access to the zone used to compute one frame
+     */
+    virtual void info(size_t /*size*/, size_t /*reads*/, size_t /*writes*/) {}
+
+    /**
+     * Inform the Memory Manager that all memory zones have been described,
+     * to possibly start a 'compute the best allocation strategy' step.
+     */
+    virtual void end() {}
+    
+    /**
+     * Allocate a memory zone.
+     * @param size - the memory zone size in bytes
+     */
+    virtual void* allocate(size_t size) = 0;
+    
+    /**
+     * Destroy a memory zone.
+     * @param ptr - the memory zone pointer to be deallocated
+     */
+    virtual void destroy(void* ptr) = 0;
+    
+};
+
+/**
+* Signal processor definition.
+*/
+
+class FAUST_API dsp {
+
+    public:
+
+        dsp() {}
+        virtual ~dsp() {}
+
+        /* Return instance number of audio inputs */
+        virtual int getNumInputs() = 0;
+    
+        /* Return instance number of audio outputs */
+        virtual int getNumOutputs() = 0;
+    
+        /**
+         * Trigger the ui_interface parameter with instance specific calls
+         * to 'openTabBox', 'addButton', 'addVerticalSlider'... in order to build the UI.
+         *
+         * @param ui_interface - the user interface builder
+         */
+        virtual void buildUserInterface(UI* ui_interface) = 0;
+    
+        /* Return the sample rate currently used by the instance */
+        virtual int getSampleRate() = 0;
+    
+        /**
+         * Global init, calls the following methods:
+         * - static class 'classInit': static tables initialization
+         * - 'instanceInit': constants and instance state initialization
+         *
+         * @param sample_rate - the sampling rate in Hz
+         */
+        virtual void init(int sample_rate) = 0;
+
+        /**
+         * Init instance state
+         *
+         * @param sample_rate - the sampling rate in Hz
+         */
+        virtual void instanceInit(int sample_rate) = 0;
+    
+        /**
+         * Init instance constant state
+         *
+         * @param sample_rate - the sampling rate in Hz
+         */
+        virtual void instanceConstants(int sample_rate) = 0;
+    
+        /* Init default control parameters values */
+        virtual void instanceResetUserInterface() = 0;
+    
+        /* Init instance state (like delay lines...) but keep the control parameter values */
+        virtual void instanceClear() = 0;
+ 
+        /**
+         * Return a clone of the instance.
+         *
+         * @return a copy of the instance on success, otherwise a null pointer.
+         */
+        virtual dsp* clone() = 0;
+    
+        /**
+         * Trigger the Meta* parameter with instance specific calls to 'declare' (key, value) metadata.
+         *
+         * @param m - the Meta* meta user
+         */
+        virtual void metadata(Meta* m) = 0;
+    
+        /**
+         * DSP instance computation, to be called with successive in/out audio buffers.
+         *
+         * @param count - the number of frames to compute
+         * @param inputs - the input audio buffers as an array of non-interleaved FAUSTFLOAT samples (eiher float, double or quad)
+         * @param outputs - the output audio buffers as an array of non-interleaved FAUSTFLOAT samples (eiher float, double or quad)
+         *
+         */
+        virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) = 0;
+    
+        /**
+         * DSP instance computation: alternative method to be used by subclasses.
+         *
+         * @param date_usec - the timestamp in microsec given by audio driver.
+         * @param count - the number of frames to compute
+         * @param inputs - the input audio buffers as an array of non-interleaved FAUSTFLOAT samples (either float, double or quad)
+         * @param outputs - the output audio buffers as an array of non-interleaved FAUSTFLOAT samples (either float, double or quad)
+         *
+         */
+        virtual void compute(double /*date_usec*/, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { compute(count, inputs, outputs); }
+       
+};
+
+/**
+ * Generic DSP decorator.
+ */
+
+class FAUST_API decorator_dsp : public dsp {
+
+    protected:
+
+        dsp* fDSP;
+
+    public:
+
+        decorator_dsp(dsp* dsp = nullptr):fDSP(dsp) {}
+        virtual ~decorator_dsp() { delete fDSP; }
+
+        virtual int getNumInputs() { return fDSP->getNumInputs(); }
+        virtual int getNumOutputs() { return fDSP->getNumOutputs(); }
+        virtual void buildUserInterface(UI* ui_interface) { fDSP->buildUserInterface(ui_interface); }
+        virtual int getSampleRate() { return fDSP->getSampleRate(); }
+        virtual void init(int sample_rate) { fDSP->init(sample_rate); }
+        virtual void instanceInit(int sample_rate) { fDSP->instanceInit(sample_rate); }
+        virtual void instanceConstants(int sample_rate) { fDSP->instanceConstants(sample_rate); }
+        virtual void instanceResetUserInterface() { fDSP->instanceResetUserInterface(); }
+        virtual void instanceClear() { fDSP->instanceClear(); }
+        virtual decorator_dsp* clone() { return new decorator_dsp(fDSP->clone()); }
+        virtual void metadata(Meta* m) { fDSP->metadata(m); }
+        // Beware: subclasses usually have to overload the two 'compute' methods
+        virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { fDSP->compute(count, inputs, outputs); }
+        virtual void compute(double date_usec, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { fDSP->compute(date_usec, count, inputs, outputs); }
+    
+};
+
+/**
+ * DSP factory class, used with LLVM and Interpreter backends
+ * to create DSP instances from a compiled DSP program.
+ */
+
+class FAUST_API dsp_factory {
+    
+    protected:
+    
+        // So that to force sub-classes to use deleteDSPFactory(dsp_factory* factory);
+        virtual ~dsp_factory() {}
+    
+    public:
+    
+        /* Return factory name */
+        virtual std::string getName() = 0;
+    
+        /* Return factory SHA key */
+        virtual std::string getSHAKey() = 0;
+    
+        /* Return factory expanded DSP code */
+        virtual std::string getDSPCode() = 0;
+    
+        /* Return factory compile options */
+        virtual std::string getCompileOptions() = 0;
+    
+        /* Get the Faust DSP factory list of library dependancies */
+        virtual std::vector<std::string> getLibraryList() = 0;
+    
+        /* Get the list of all used includes */
+        virtual std::vector<std::string> getIncludePathnames() = 0;
+    
+        /* Get warning messages list for a given compilation */
+        virtual std::vector<std::string> getWarningMessages() = 0;
+    
+        /* Create a new DSP instance, to be deleted with C++ 'delete' */
+        virtual dsp* createDSPInstance() = 0;
+    
+        /* Static tables initialization, possibly implemened in sub-classes*/
+        virtual void classInit(int sample_rate) {};
+    
+        /* Set a custom memory manager to be used when creating instances */
+        virtual void setMemoryManager(dsp_memory_manager* manager) = 0;
+    
+        /* Return the currently set custom memory manager */
+        virtual dsp_memory_manager* getMemoryManager() = 0;
+    
+};
+
+// Denormal handling
+
+#if defined (__SSE__)
+#include <xmmintrin.h>
+#endif
+
+class FAUST_API ScopedNoDenormals {
+    
+    private:
+    
+        intptr_t fpsr = 0;
+        
+        void setFpStatusRegister(intptr_t fpsr_aux) noexcept
+        {
+        #if defined (__arm64__) || defined (__aarch64__)
+            asm volatile("msr fpcr, %0" : : "ri" (fpsr_aux));
+        #elif defined (__SSE__)
+            // The volatile keyword here is needed to workaround a bug in AppleClang 13.0
+            // which aggressively optimises away the variable otherwise
+            volatile uint32_t fpsr_w = static_cast<uint32_t>(fpsr_aux);
+            _mm_setcsr(fpsr_w);
+        #endif
+        }
+        
+        void getFpStatusRegister() noexcept
+        {
+        #if defined (__arm64__) || defined (__aarch64__)
+            asm volatile("mrs %0, fpcr" : "=r" (fpsr));
+        #elif defined (__SSE__)
+            fpsr = static_cast<intptr_t>(_mm_getcsr());
+        #endif
+        }
+    
+    public:
+    
+        ScopedNoDenormals() noexcept
+        {
+        #if defined (__arm64__) || defined (__aarch64__)
+            intptr_t mask = (1 << 24 /* FZ */);
+        #elif defined (__SSE__)
+        #if defined (__SSE2__)
+            intptr_t mask = 0x8040;
+        #else
+            intptr_t mask = 0x8000;
+        #endif
+        #else
+            intptr_t mask = 0x0000;
+        #endif
+            getFpStatusRegister();
+            setFpStatusRegister(fpsr | mask);
+        }
+        
+        ~ScopedNoDenormals() noexcept
+        {
+            setFpStatusRegister(fpsr);
+        }
+
+};
+
+#define AVOIDDENORMALS ScopedNoDenormals ftz_scope;
+
+#endif
+
+/************************** END dsp.h **************************/