// Options:
/* ------------------------------------------------------------
name: "FaustSawtooth"
Code generated with Faust 2.70.3 (https://faust.grame.fr)
Compilation options: -a /opt/homebrew/Cellar/faust/2.70.3/share/faust/esp32/esp32.cpp -lang cpp -i -ct 1 -es 1 -mcd 16 -mdd 1024 -mdy 33 -single -ftz 0
------------------------------------------------------------ */
#ifndef __mydsp_H__
#define __mydsp_H__
/************************************************************************
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 .
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 "FaustSawtooth.h"
/************************** BEGIN meta.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 __meta__
#define __meta__
/************************************************************************
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 __export__
#define __export__
// Version as a global string
#define FAUSTVERSION "2.70.3"
// Version as separated [major,minor,patch] values
#define FAUSTMAJORVERSION 2
#define FAUSTMINORVERSION 70
#define FAUSTPATCHVERSION 3
// Use FAUST_API for code that is part of the external API but is also compiled in faust and libfaust
// Use LIBFAUST_API for code that is compiled in faust and libfaust
#ifdef _WIN32
#pragma warning (disable: 4251)
#ifdef FAUST_EXE
#define FAUST_API
#define LIBFAUST_API
#elif FAUST_LIB
#define FAUST_API __declspec(dllexport)
#define LIBFAUST_API __declspec(dllexport)
#else
#define FAUST_API
#define LIBFAUST_API
#endif
#else
#ifdef FAUST_EXE
#define FAUST_API
#define LIBFAUST_API
#else
#define FAUST_API __attribute__((visibility("default")))
#define LIBFAUST_API __attribute__((visibility("default")))
#endif
#endif
#endif
/**
The base class of Meta handler to be used in dsp::metadata(Meta* m) method to retrieve (key, value) metadata.
*/
struct FAUST_API Meta {
virtual ~Meta() {}
virtual void declare(const char* key, const char* value) = 0;
};
#endif
/************************** END meta.h **************************/
/************************** 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
#include
#include
#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 getLibraryList() = 0;
/* Get the list of all used includes */
virtual std::vector getIncludePathnames() = 0;
/* Get warning messages list for a given compilation */
virtual std::vector 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
#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(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(_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 **************************/
/************************** BEGIN MapUI.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 FAUST_MAPUI_H
#define FAUST_MAPUI_H
#include
#include