diff -Nru faust-2.50.6+ds0/appveyor.yml faust-2.54.9+ds0/appveyor.yml --- faust-2.50.6+ds0/appveyor.yml 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/appveyor.yml 2022-12-17 10:41:42.000000000 +0000 @@ -7,7 +7,7 @@ - cd build - mkdir win64 - cd win64 - - cmake -C ../backends/regular.cmake -C ../targets/regular.cmake .. -G "Visual Studio 15 2017 Win64" + - cmake -C ../backends/regular.cmake -C ../targets/regular.cmake .. -G "Visual Studio 16 2019" -A x64 - cmake --build . --config Release - ls -l ../bin/Release diff -Nru faust-2.50.6+ds0/architecture/android/app/build.gradle faust-2.54.9+ds0/architecture/android/app/build.gradle --- faust-2.50.6+ds0/architecture/android/app/build.gradle 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/android/app/build.gradle 2022-12-17 10:41:42.000000000 +0000 @@ -1,13 +1,13 @@ apply plugin: 'com.android.application' android { - compileSdkVersion 30 + compileSdkVersion 33 defaultConfig { applicationId "com.faust" minSdkVersion 16 - targetSdkVersion 30 - versionCode 1 - versionName "1.0" + targetSdkVersion 33 + versionCode 205 + versionName "1.3" testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" externalNativeBuild { cmake { diff -Nru faust-2.50.6+ds0/architecture/android/app/src/main/AndroidManifest.xml faust-2.54.9+ds0/architecture/android/app/src/main/AndroidManifest.xml --- faust-2.50.6+ds0/architecture/android/app/src/main/AndroidManifest.xml 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/android/app/src/main/AndroidManifest.xml 2022-12-17 10:41:42.000000000 +0000 @@ -18,16 +18,17 @@

getNumTouches() > 0) - val = sensor->compoundTouchLocation(); + if (fSensor && fSensor->getNumTouches() > 0) + val = fSensor->compoundTouchLocation(); *fZone = fMin + fRange * val; break; @@ -680,8 +782,8 @@ case kBAR_LVL_5: case kBAR_LVL_6: case kBAR_LVL_7: - if (sensor && sensor->getNumTouches() > 0) - val = sensor->compoundTouchSize(); + if (fSensor && fSensor->getNumTouches() > 0) + val = fSensor->compoundTouchSize(); *fZone = fMin + fRange * val; break; @@ -693,9 +795,9 @@ case kBAR_TOUCH_5: case kBAR_TOUCH_6: case kBAR_TOUCH_7: - if (sensor) - val = sensor->getNumTouches(); - *fZone = max(fRange,val); + if (fSensor) + val = fSensor->getNumTouches(); + *fZone = min(fRange,val); break; case kSQUARE_XPOS_0: @@ -706,8 +808,8 @@ case kSQUARE_XPOS_5: case kSQUARE_XPOS_6: case kSQUARE_XPOS_7: - if (sensor && sensor->getNumTouches() > 0) - val = sensor->compoundTouchHorizontalLocation(); + if (fSensor && fSensor->getNumTouches() > 0) + val = fSensor->compoundTouchHorizontalLocation(); *fZone = fMin + fRange * val; break; @@ -719,8 +821,8 @@ case kSQUARE_YPOS_5: case kSQUARE_YPOS_6: case kSQUARE_YPOS_7: - if (sensor && sensor->getNumTouches() > 0) - val = sensor->compoundTouchLocation(); + if (fSensor && fSensor->getNumTouches() > 0) + val = fSensor->compoundTouchLocation(); *fZone = fMin + fRange * val; break; @@ -732,8 +834,8 @@ case kSQUARE_LVL_5: case kSQUARE_LVL_6: case kSQUARE_LVL_7: - if (sensor && sensor->getNumTouches() > 0) - val = sensor->compoundTouchSize(); + if (fSensor && fSensor->getNumTouches() > 0) + val = fSensor->compoundTouchSize(); *fZone = fMin + fRange * val; break; @@ -745,9 +847,9 @@ case kSQUARE_TOUCH_5: case kSQUARE_TOUCH_6: case kSQUARE_TOUCH_7: - if (sensor) - val = sensor->getNumTouches(); - *fZone = max(fRange,val); + if (fSensor) + val = fSensor->getNumTouches(); + *fZone = min(fRange,val); break; default: @@ -755,17 +857,16 @@ }; } - Trill::Device getType() { return type; } + Trill::Device getType() { return fType; } - Trill* getSensor() { return sensor; } + Trill* getSensor() { return fSensor; } }; /************************************************************************************** - TrillCraftWidget : object used by BelaUI to ensures the connection between a Trill Craft sensors values and a Faust widget. - ***************************************************************************************/ + typedef struct { int note; double state; @@ -775,15 +876,15 @@ { protected: - int lopin; - int hipin; - string mode; - int prescaler; - double threshold; - - vector Keyboard; // list of keys in the trillkeyboard (polyphony mode) - int start_note; - vector Scale; // in semitone + int fLopin; + int fHipin; + string fMode; + int fPrescaler; + double fThreshold; + + vector fKeyboard; // list of keys in the trillkeyboard (polyphony mode) + int fStartNote; + vector fScale; // in semitone int noteToMidiNumber(const string& note, int octave) // return the midi number of the note at the octave defined { @@ -805,48 +906,52 @@ TrillCraftWidget():TrillWidget() { - sensor = NULL; - type = Trill::CRAFT; - lopin = -1; - hipin = -1; - mode = "PIN"; - prescaler = 2; - threshold = 0.10; - start_note = 0; + fSensor = NULL; + fType = Trill::CRAFT; + fLopin = -1; + fHipin = -1; + fMode = "PIN"; + fPrescaler = 2; + fThreshold = 0.10; + fStartNote = 0; + fScale.push_back(1); // default chromatic scale } TrillCraftWidget(const TrillCraftWidget& w):TrillWidget((TrillWidget)w) { - sensor = NULL; - type = Trill::CRAFT; - lopin = -1; - hipin = -1; - mode = "PIN"; - prescaler = 2; - threshold = 0.10; - start_note = 0; + fSensor = NULL; + fType = Trill::CRAFT; + fLopin = -1; + fHipin = -1; + fMode = "PIN"; + fPrescaler = 2; + fThreshold = 0.10; + fStartNote = 0; + fScale.push_back(1); // default chromatic scale } - TrillCraftWidget(EInOutPin pin, FAUSTFLOAT* z, const char* l, FAUSTFLOAT lo, FAUSTFLOAT hi) + TrillCraftWidget(EInOutPin pin, FAUSTFLOAT* z, const char* l, FAUSTFLOAT lo, FAUSTFLOAT hi, FAUSTFLOAT step) { fBelaPin = pin; fZone = z; // zone fLabel = l; // label fMin = lo; // minimal value fRange = hi; - sensor = NULL; - type = Trill::CRAFT; - lopin = -1; - hipin = -1; - mode = "PIN"; - prescaler = 2; - threshold = 0.10; - start_note = 0; + fStep = step; + fSensor = NULL; + fType = Trill::CRAFT; + fLopin = -1; + fHipin = -1; + fMode = "PIN"; + fPrescaler = 2; + fThreshold = 0.10; + fStartNote = 0; + fScale.push_back(1); //default chromatic scale } virtual ~TrillCraftWidget() { - for (auto t : Keyboard) { + for (auto t : fKeyboard) { delete t; } } @@ -854,9 +959,9 @@ virtual void setSensor(Trill* nSensor) { TrillWidget::setSensor(nSensor); - if (sensor) { - sensor->setPrescaler(prescaler); - sensor->setNoiseThreshold(threshold); + if (fSensor) { + fSensor->setPrescaler(fPrescaler); + fSensor->setNoiseThreshold(fThreshold); } } @@ -864,133 +969,194 @@ { if (parameters && !TrillWidget::setParameters(parameters)) { if (parseWord(parameters, "PIN")) { - mode = "PIN"; + fMode = "PIN"; } else if (parseWord(parameters, "UP")) { - mode = "UP"; + fMode = "UP"; } else if (parseWord(parameters, "DOWN")) { - mode = "DOWN"; + fMode = "DOWN"; + } else if (parseWord(parameters, "SLIDER")) { + fMode = "SLIDER"; } double tmpval = 0.; if (parameters && parseDouble(parameters, tmpval)) { - lopin = (int)tmpval; + fLopin = (int)tmpval; } else { - lopin = -1; + fLopin = -1; } if (parameters && parseChar(parameters, '-') && parseDouble(parameters, tmpval)) { - hipin = (int)tmpval; + fHipin = (int)tmpval; } else { - hipin = -1; + fHipin = -1; } } return true; } - - virtual void setParameter(const string& name, double value) + + virtual void setParameter(const string& name, const double value) { - TrillWidget::setParameter(name, value); - if (name == "prescaler") prescaler = (int)value; - else if (name == "threshold") threshold = (int)value; - else if (name == "start_pin") lopin = (int)value; - else if (name == "end_pin") hipin = (int)value; + TrillWidget::setParameter(name,value); + if (name == "fPrescaler") fPrescaler = (int)value; + else if (name == "fThreshold") fThreshold = (int)value; + else if (name == "start_pin") fLopin = (int)value; + else if (name == "end_pin") fHipin = (int)value; } virtual void setParameter(const string& name, const string& value) { - const char* tmpval = value.c_str(); + const char* tmpval=value.c_str(); if (name == "start_note") { vector names; vector values; - if (parseMenuList(tmpval, names, values) && names.size() > 0) { - start_note = noteToMidiNumber(names[0], (int)values[0]); + if (parseMenuList(tmpval,names,values) && names.size() > 0) { + fStartNote = noteToMidiNumber(names[0],(int) values[0]); } } else if (name == "scale") { vector values; - if (parseListDouble(tmpval, values) && values.size() > 0) { - for (int i = 0; i < values.size(); i++) { - Scale.push_back((int)(values[i]*2)); - } + if (parseListDouble(tmpval,values) && values.size() > 0) { + fScale.clear(); + for (int i = 0 ; i= 0) + if (fSensor && fLopin >= 0) { float val = -1.f; - if (mode == "PIN") { - val = sensor->rawData[lopin]; - *fZone = fMin + fRange * val; + if (fMode == "PIN") { + *fZone = fMin + fRange * fSensor->rawData[fLopin]; } - else if (mode == "UP") { + else if (fMode == "UP") { float sval = 0.f; - for (int i = hipin; i >= lopin; i--) + for (int i = fHipin; i >= fLopin; i--) { - sval = sensor->rawData[i]; + sval = fSensor->rawData[i]; if (sval > 0.f) { - val = i-lopin; + val = i-fLopin; break; } } *fZone = val; } - else if (mode == "DOWN") { + else if (fMode == "DOWN") { float sval = 0.f; - for (int i = lopin; i <= hipin; i++) + for (int i = fLopin; i <= fHipin; i++) { - sval = sensor->rawData[i]; + sval = fSensor->rawData[i]; if (sval > 0.f) { - val = i-lopin; + val = i-fLopin; break; } } *fZone = val; - } else if (mode == "KEYBOARD") { - mydsp_poly* TmpDsp = (mydsp_poly*)gDSP; - for (int i = lopin; i <= hipin; i++) { - TrillNote* CurKey = Keyboard[i-lopin]; - double sval = sensor->rawData[i]; + } else if (fMode == "KEYBOARD") { + mydsp_poly* TmpDsp = (mydsp_poly*) gDSP; + for (int i = fLopin ; i <= fHipin ; i++) { //Call all keyOff + TrillNote* CurKey = fKeyboard[i-fLopin]; + double sval = fSensor->rawData[i]; if (sval == 0 && CurKey->state > 0) { TmpDsp->keyOff(0,CurKey->note); - CurKey->state = 0; - } else if (sval > 0 && CurKey->state == 0) { - TmpDsp->keyOn(0,CurKey->note, (int) (sval*127)); - CurKey->state = sval; + CurKey->state=0; } } + for (int i = fLopin ; i <= fHipin ; i++) { //Call all keyOn + TrillNote* CurKey = fKeyboard[i-fLopin]; + double sval = fSensor->rawData[i]; + if (sval > 0 && CurKey->state == 0) { + TmpDsp->keyOn(0,CurKey->note, (int) (sval*127)); + CurKey->state=sval; + } + } } } } void setMode(const string& mo) { - mode = mo; - if (mode == "KEYBOARD" && lopin >= 0 && hipin >= lopin && start_note > 0) { // create the array of trill keyboard - double curnote = start_note; + fMode = mo; + if (fMode == "KEYBOARD" && fLopin >= 0 && fHipin >= fLopin && fStartNote > 0) { // create the array of trill keyboard + double curnote = fStartNote; int scalecounter = 0; - for (int i = lopin ; i <= hipin ; i++) { + for (int i = fLopin ; i <= fHipin ; i++) { TrillNote* newkey = new TrillNote; newkey->note = curnote; newkey->state = 0; - Keyboard.push_back(newkey); - if (Scale.size() > 0) { //configure the custom scale - if (scalecounter >= Scale.size()) { - scalecounter = 0; - } - curnote = curnote + Scale[scalecounter]; - scalecounter++; - } else { - curnote = curnote + 1; // configure default scale (chromatic) + fKeyboard.push_back(newkey); + if (scalecounter >= fScale.size()) { + scalecounter = 0; } + curnote = curnote + fScale[scalecounter]; + scalecounter++; } } } - void setLopin(int pin) { lopin = pin; } + void setLopin(int pin) { fLopin = pin; } - void setHipin(int pin) { hipin = pin; } + void setHipin(int pin) { fHipin = pin; } +}; + +class TrillCraftWidgetCheckBox : public TrillCraftWidget +{ + protected: + CheckBoxLogic fChkBoxSystem; + + public: + + TrillCraftWidgetCheckBox(): TrillCraftWidget() {} + + TrillCraftWidgetCheckBox(const TrillCraftWidgetCheckBox& w): TrillCraftWidget((TrillCraftWidget) w) {} + + TrillCraftWidgetCheckBox(EInOutPin pin, FAUSTFLOAT* z, const char* l, FAUSTFLOAT lo, FAUSTFLOAT hi, FAUSTFLOAT step): TrillCraftWidget(pin, z, l, lo, hi, step) {} + + virtual ~TrillCraftWidgetCheckBox() {} + + virtual void update(BelaContext* context) + { + if (fSensor && fLopin >= 0 && fMode == "PIN") + { + double value = fSensor->rawData[fLopin]; + bool value_state = fChkBoxSystem.getOutState((bool) value); + *fZone = fMin + fRange * value_state; + } + } +}; + +class TrillCraftWidgetSlider : public TrillCraftWidget +{ + protected: + UpDownKeyLogic fSliderSystem; + + public: + + TrillCraftWidgetSlider(): TrillCraftWidget() {} + + TrillCraftWidgetSlider(const TrillCraftWidgetCheckBox& w): TrillCraftWidget((TrillCraftWidget) w) {} + + TrillCraftWidgetSlider(EInOutPin pin, FAUSTFLOAT* z, const char* l, FAUSTFLOAT lo, FAUSTFLOAT hi, FAUSTFLOAT step ): TrillCraftWidget(pin, z, l, lo, hi, step) { + + } + + virtual ~TrillCraftWidgetSlider() {} + + virtual void update(BelaContext* context) + { + if (fSensor && fLopin >= 0 && fMode == "SLIDER") + { + double downKey = fSensor->rawData[fLopin]; + double upKey = fSensor->rawData[fHipin]; + double value_state = (double) fSliderSystem.getOutState(downKey, upKey); + double tmpval = *fZone + fStep * value_state; + if (tmpval >= fMin && tmpval <= (fRange+fMin)) { + *fZone=tmpval; + } + } + } }; /************************************************************************************** @@ -1008,6 +1174,7 @@ #define MAXBELAWIDGETS 16 // Max number of trill sensors parameters mapped. + // max of 8 BAR sensors with 3 parameters (Position,Pressure,Touch), 8 SQUARE sensors with 4 parameters // (Position X, Position Y, Pressure, Touch), 8 CRAFT sensors with 1 parameter #define MAXTRILLWIDGETS 64 @@ -1028,29 +1195,81 @@ vector fTouchSensors; // list of Trill sensors // Check if the widget is linked to a Bela parameter and, if so, add the corresponding BelaWidget - void addBelaWidget(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT lo, FAUSTFLOAT hi) + void addBelaWidget(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT lo, FAUSTFLOAT hi, FAUSTFLOAT step) + { + if (fBelaPin != kNoPin && (fIndex < MAXBELAWIDGETS)) { + fTable[fIndex] = BelaWidget(fBelaPin, zone, label, lo, hi, step); + fIndex++; + } + fBelaPin = kNoPin; + } + void addBelaWidgetCheckBox(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT lo, FAUSTFLOAT hi) { if (fBelaPin != kNoPin && (fIndex < MAXBELAWIDGETS)) { - fTable[fIndex] = BelaWidget(fBelaPin, zone, label, lo, hi); + fTable[fIndex] = BelaWidgetCheckBox(fBelaPin, zone, label, lo, hi, 0); fIndex++; } fBelaPin = kNoPin; } - void addTrillWidget(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT lo, FAUSTFLOAT hi) + void addTrillWidget(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT lo, FAUSTFLOAT hi, FAUSTFLOAT step) + { + if (fTrillPin != kNoPin) { + + if (strstr(pinNamesStrings[fTrillPin], "CRAFT")) + { + TrillCraftWidget* newcraft = new TrillCraftWidget(fTrillPin, zone, label, lo, hi, step); + newcraft->setParameters(fTrillParams); + fTrillTable.push_back(newcraft); + } + else + { + TrillWidget* newtrill = new TrillWidget(fTrillPin, zone, label, lo, hi, step); + newtrill->setParameters(fTrillParams); + fTrillTable.push_back(newtrill); + } + + } + fTrillPin = kNoPin; + fTrillParams = NULL; + } + + void addTrillWidgetCheckBox(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT lo, FAUSTFLOAT hi) { - if (fTrillPin != kNoPin && (fTrillTable.size() < MAXTRILLWIDGETS)) { + if (fTrillPin != kNoPin) { if (strstr(pinNamesStrings[fTrillPin], "CRAFT")) { - TrillCraftWidget* newcraft = new TrillCraftWidget(fTrillPin, zone, label, lo, hi); - newcraft->setParameters(fTrillParams); + TrillCraftWidgetCheckBox* newcraft = new TrillCraftWidgetCheckBox(fTrillPin, zone, label, lo, hi, 0); + newcraft->setParameters(fTrillParams); + fTrillTable.push_back(newcraft); + } + } + fTrillPin = kNoPin; + fTrillParams = NULL; + } + + void addTrillWidgetSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT lo, FAUSTFLOAT hi, FAUSTFLOAT step) + { + if (fTrillPin != kNoPin) { + + TrillCraftWidget* newcraft; + if (strstr(pinNamesStrings[fTrillPin], "CRAFT")) + { + if (strstr(fTrillParams, "SLIDER")) { + TrillCraftWidgetSlider* newcraftslider = new TrillCraftWidgetSlider(fTrillPin, zone, label, lo, hi, step); + newcraft = (TrillCraftWidget*) newcraftslider; + } else { + TrillCraftWidget* newcraftsensor = new TrillCraftWidget(fTrillPin, zone, label, lo, hi, step); + newcraft = newcraftsensor; + } + newcraft->setParameters(fTrillParams); fTrillTable.push_back(newcraft); } else { - TrillWidget* newtrill = new TrillWidget(fTrillPin, zone, label, lo, hi); - newtrill->setParameters(fTrillParams); + TrillWidget* newtrill = new TrillWidget(fTrillPin, zone, label, lo, hi, step); + newtrill->setParameters(fTrillParams); fTrillTable.push_back(newtrill); } @@ -1111,48 +1330,48 @@ virtual void addButton(const char* label, FAUSTFLOAT* zone) { if (fBelaPin != kNoPin) - addBelaWidget(label, zone, FAUSTFLOAT(0), FAUSTFLOAT(1)); + addBelaWidget(label, zone, FAUSTFLOAT(0), FAUSTFLOAT(1),0); else - addTrillWidget(label, zone, FAUSTFLOAT(0), FAUSTFLOAT(1)); + addTrillWidget(label, zone, FAUSTFLOAT(0), FAUSTFLOAT(1),0); } virtual void addCheckButton(const char* label, FAUSTFLOAT* zone) { if (fBelaPin != kNoPin) - addBelaWidget(label, zone, FAUSTFLOAT(0), FAUSTFLOAT(1)); + addBelaWidgetCheckBox(label, zone, FAUSTFLOAT(0), FAUSTFLOAT(1)); else - addTrillWidget(label, zone, FAUSTFLOAT(0), FAUSTFLOAT(1)); + addTrillWidgetCheckBox(label, zone, FAUSTFLOAT(0), FAUSTFLOAT(1)); } virtual void addVerticalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT lo, FAUSTFLOAT hi, FAUSTFLOAT step) { if (fBelaPin != kNoPin) - addBelaWidget(label, zone, lo, hi); + addBelaWidget(label, zone, lo, hi, step); else - addTrillWidget(label, zone, lo, hi); + addTrillWidgetSlider(label, zone, lo, hi, step); } virtual void addHorizontalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT lo, FAUSTFLOAT hi, FAUSTFLOAT step) { if (fBelaPin != kNoPin) - addBelaWidget(label, zone, lo, hi); + addBelaWidget(label, zone, lo, hi, step); else - addTrillWidget(label, zone, lo, hi); + addTrillWidgetSlider(label, zone, lo, hi, step); } virtual void addNumEntry(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT lo, FAUSTFLOAT hi, FAUSTFLOAT step) { if (fBelaPin != kNoPin) - addBelaWidget(label, zone, lo, hi); + addBelaWidget(label, zone, lo, hi, step); else - addTrillWidget(label, zone, lo, hi); + addTrillWidget(label, zone, lo, hi, step); } // -- passive widgets virtual void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT lo, FAUSTFLOAT hi) - { addBelaWidget(label, zone, lo, hi); } + { addBelaWidget(label, zone, lo, hi, 0); } virtual void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT lo, FAUSTFLOAT hi) - { addBelaWidget(label, zone, lo, hi); } + { addBelaWidget(label, zone, lo, hi, 0); } // -- metadata declarations virtual void declare(FAUSTFLOAT* z, const char* k, const char* id) @@ -1201,9 +1420,9 @@ for (int i = 0; i values; if (parseMenuListMenu(id, names, values)) { for (int i = 0; isetParameters(values[i].c_str()); newcraft->setMode("KEYBOARD"); fTrillTable.push_back(newcraft); @@ -1478,4 +1697,3 @@ } /******************** END bela.cpp ****************/ - diff -Nru faust-2.50.6+ds0/architecture/cmajor/cmajor-faust-editor.cpp faust-2.54.9+ds0/architecture/cmajor/cmajor-faust-editor.cpp --- faust-2.50.6+ds0/architecture/cmajor/cmajor-faust-editor.cpp 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/cmajor/cmajor-faust-editor.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,146 @@ +/************************************************************************ + FAUST Architecture File + Copyright (C) 2021-2022 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 . + + 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 +#include +#include +#include +#include + +#include "cmajor-tools.h" +#include "faust/dsp/llvm-dsp.h" +#include "faust/misc.h" + +using namespace std; + +static bool endWith(const string& str, const string& suffix) +{ + size_t i = str.rfind(suffix); + return (i != string::npos) && (i == (str.length() - suffix.length())); +} + +struct HybridEditor { + + string fInFilename; + string fOutFilename; + int fArgc1; + const char** fArgv1; + efsw_watcher fEfsw; + + HybridEditor(const string& in_filename, + const string& out_filename, + int argc1, + const char* argv1[]) + :fInFilename(in_filename), fOutFilename(out_filename), fArgc1(argc1), fArgv1(argv1) + { + char temp[PATH_MAX + 1]; + char* path = realpath(in_filename.c_str(), temp); + std::string dir = dirname(path); + + fEfsw = efsw_create(false); + efsw_addwatch(fEfsw, dir.c_str(), watchCallback, false, this); + efsw_watch(fEfsw); + + compilePatch(); + + cout << "Type 'q' to Quit\n"; + char c; + while ((c = getchar()) && (c != 'q')) {} + } + + virtual ~HybridEditor() + { + efsw_release(fEfsw); + } + + void compilePatch() + { + cout << "compilePatch : '" << fInFilename << "' to '" << fOutFilename << "' and '" << fOutFilename + "patch'" << endl; + // We have a pure Cmajor file or a Faust/Cmajor file, parse it, compile the Faust part to Cmajor, generate the Cmajor result + faust_cmajor_parser parser; + if (!parser.parseCmajorFile(fInFilename, fOutFilename, fArgc1, fArgv1)) { + cerr << "ERROR : file '" << fInFilename << "' cannot be opened or compiled!\n"; + return; + } + + // Generate "cmajorpatch" file + parser.createCmajorPatch(fOutFilename); + } + + static void watchCallback(efsw_watcher watcher, + efsw_watchid watchid, + const char* dir, + const char* filename, + enum efsw_action action, + const char* old_filename, + void* param) + { + HybridEditor* editor = (HybridEditor*)param; + if (action == EFSW_ADD + || action == EFSW_DELETE + || action == EFSW_MODIFIED + || action == EFSW_MOVED) { + // Check filename + if (string(filename) == editor->fInFilename) { + editor->compilePatch(); + } + } + } + +}; + +int main(int argc, char* argv[]) +{ + if (isopt(argv, "-h") || isopt(argv, "-help")) { + cout << "Copyright (c) 2021-2022 Grame, version 0.2" << endl; + cout << "Usage: cmajor-faust-editor [Faust options : any option (e.g. -ftz 1...)] -o " << endl; + exit(-1); + } + + string in_filename; + string out_filename = "hybrid.cmajor"; + int argc1 = 0; + const char* argv1[64]; + for (int i = 1; i < argc; i++) { + if (endWith(string(argv[i]), ".cmajor")) { + in_filename = argv[i]; + continue; + } else if (string(argv[i]) == "-o") { + out_filename = argv[i+1]; + i++; + continue; + } + argv1[argc1++] = argv[i]; + } + + cout << "Libfaust version : " << getCLibFaustVersion() << endl; + + if (endWith(in_filename, "cmajor")) { + HybridEditor editor(in_filename, out_filename, argc1, argv1); + } else { + cout << "ERROR : incorrect file type" << endl; + exit(-1); + } + + return 0; +} diff -Nru faust-2.50.6+ds0/architecture/cmajor/cmajor-faust-player.cpp faust-2.54.9+ds0/architecture/cmajor/cmajor-faust-player.cpp --- faust-2.50.6+ds0/architecture/cmajor/cmajor-faust-player.cpp 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/cmajor/cmajor-faust-player.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,141 @@ +/************************************************************************ + FAUST Architecture File + Copyright (C) 2019-2022 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 . + + 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 +#include + +#include "faust/gui/GTKUI.h" +#include "faust/audio/jack-dsp.h" +#include "faust/dsp/cmajorpatch-dsp.h" +#include "cmajor-tools.h" +#include "faust/dsp/libfaust.h" +#include "faust/misc.h" +#include "faust/midi/rt-midi.h" +#include "faust/midi/RtMidi.cpp" +#include + +using namespace std; + +list GUI::fGuiList; +ztimedmap GUI::gTimedZoneMap; + +#define FAUST_FILE "faust.cmajor" +#define FAUST_PATCH_FILE "faust.cmajorpatch" + +#define HYBRID_FILE "hybrid.cmajor" +#define HYBRID_PATCH_FILE "hybrid.cmajorpatch" + +inline bool endWith(const string& str, const string& suffix) +{ + size_t i = str.rfind(suffix); + return (i != string::npos) && (i == (str.length() - suffix.length())); +} + +int main(int argc, char* argv[]) +{ + if (isopt(argv, "-h") || isopt(argv, "-help")) { + cout << "cmajor-faust-player (pure Faust code), (pure Cmajor patch) or (pure Cmajor code or Faust/Cmajor hybrid code)" << endl; + exit(-1); + } + + char* filename = argv[argc-1]; + string real_file; + + int argc1 = 0; + const char* argv1[64]; + for (int i = 1; i < argc-1; i++) { + argv1[argc1++] = argv[i]; + } + + if (endWith(filename, ".dsp")) { + + // We have a pure Faust file, compile it to Cmajor + faust_cmajor_parser parser; + if (!parser.generateCmajorFile(filename, FAUST_FILE, argc1, argv1)) { + cerr << "ERROR : file '" << filename << "' cannot be opened or compiled!\n"; + exit(-1); + } + + // Generate "cmajorpatch" file + parser.createCmajorPatch(FAUST_FILE); + real_file = FAUST_FILE; + + } else if (endWith(filename, ".cmajor")) { + + // We have a pure Cmajor file or a Faust/Cmajor file, parse it, compile the Faust part to Cmajor, generate the Cmajor result + faust_cmajor_parser parser; + if (!parser.parseCmajorFile(filename, HYBRID_FILE, argc1, argv1)) { + cerr << "ERROR : file '" << filename << "' cannot be opened or compiled!\n"; + exit(-1); + } + + // Generate "cmajorpatch" file + parser.createCmajorPatch(HYBRID_FILE); + real_file = HYBRID_FILE; + + } else { + cerr << "Unsupported file extension" << endl; + exit(1); + } + + try { + string error_msg; + cmajor_dsp_factory* factory = createCmajorDSPFactoryFromFile(real_file, argc, (const char**)argv, error_msg); + if (!factory) { + cerr << "Cannot create factory : " << error_msg; + exit(1); + } + cmajorpatch_dsp* DSP = factory->createDSPInstance(); + + cout << "getNumInputs " << DSP->getNumInputs() << endl; + cout << "getNumOutputs " << DSP->getNumOutputs() << endl; + + jackaudio audio; + audio.init(filename, DSP); + + // Has to be done after init + GTKUI interface(filename, &argc, &argv); + DSP->buildUserInterface(&interface); + + // MIDI handling + rt_midi midi_handler(filename, false, true); + DSP->setMidiHandler(&midi_handler); + + midi_handler.startMidi(); + audio.start(); + + interface.run(); + + midi_handler.stopMidi(); + audio.stop(); + + // Cleanup + delete DSP; + delete factory; + } catch (...) { + cerr << "ERROR : cannot allocate cmajorpatch_dsp\n"; + exit(-1); + } + + return 0; +} diff -Nru faust-2.50.6+ds0/architecture/cmajor/cmajor-faust-tester.cpp faust-2.54.9+ds0/architecture/cmajor/cmajor-faust-tester.cpp --- faust-2.50.6+ds0/architecture/cmajor/cmajor-faust-tester.cpp 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/cmajor/cmajor-faust-tester.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,142 @@ +/************************************************************************ + FAUST Architecture File + Copyright (C) 2019-2022 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 . + + 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 +#include + +#include "faust/dsp/cmajorpatch-dsp.h" +#include "cmajor-tools.h" +#include "faust/dsp/dsp-optimizer.h" +#include "faust/misc.h" +#include "faust/dsp/interpreter-dsp.h" + +#define FAUST_FILE "faust.cmajor" +#define FAUST_PATCH_FILE "faust.cmajorpatch" + +//#define INTERP + +using namespace std; + +static int buffer_size = 512; +static bool is_control = false; + +static bool endWith(const string& str, const string& suffix) +{ + size_t i = str.rfind(suffix); + return (i != string::npos) && (i == (str.length() - suffix.length())); +} + +static void measureDSP(const string& filename, dsp* DSP) +{ + // Buffer_size and duration in sec of measure, no trace and activated control + measure_dsp mes(DSP, buffer_size, 5., false, is_control); + mes.measure(); + pair res = mes.getStats(); + cout << filename << " : " << res.first << " MBytes/sec (DSP CPU % : " << (mes.getCPULoad() * 100) << " at 44100 Hz)" << endl; + FAUSTBENCH_LOG(res.first); +} + +static void testFaust(const string& filename, int argc1, const char* argv1[]) +{ + // Faust compilation and test + string error_msg; +#ifdef INTERP + dsp_factory* factory = createInterpreterDSPFactoryFromFile(filename, argc1, argv1, error_msg); +#else + dsp_factory* factory = createDSPFactoryFromFile(filename, argc1, argv1, "", error_msg, -1); +#endif + if (!factory) { + cerr << "ERROR : file '" << filename << "' cannot be opened with " << error_msg << "\n"; + exit(-1); + } + measureDSP(filename, factory->createDSPInstance()); +#ifdef INTERP + deleteInterpreterDSPFactory(static_cast(factory)); +#else + deleteDSPFactory(static_cast(factory)); +#endif +} + +static void testCmajorPatch(const string& filename, int argc1, const char* argv1[]) +{ + // Cmajor compilation and test + string error_msg; + cmajor_dsp_factory* factory = createCmajorDSPFactoryFromFile(filename, argc1, argv1, error_msg); + if (!factory) { + cerr << "ERROR : file '" << filename << "' : " << error_msg << "\n"; + exit(-1); + } + + measureDSP(filename, factory->createDSPInstance()); + delete factory; +} + +static void testCmajor(const string& filename, int argc1, const char* argv1[]) +{ + // Faust => Cmajor compilation + faust_cmajor_parser parser; + if (!parser.generateCmajorFile(filename, FAUST_FILE, argc1, argv1)) { + cerr << "ERROR : file '" << filename << "' cannot be opened or compiled! \n"; + exit(-1); + } + + // Generate "cmajorpatch" file + parser.createCmajorPatch(FAUST_FILE); + testCmajorPatch(FAUST_FILE, argc1, argv1); +} + +int main(int argc, char* argv[]) +{ + if (isopt(argv, "-h") || isopt(argv, "-help")) { + cout << "cmajor-faust-tester [-bs ] [-control] [Faust options : any option (e.g. -vec -vs 8...)] foo.dsp|foo.cmajorpatch" << endl; + cout << "Use '-bs ' to set the maximum buffer-size in frames\n"; + cout << "Use '-control' to update all controllers with random values at each cycle\n"; + exit(-1); + } + + buffer_size = lopt(argv, "-bs", 512); + is_control = isopt(argv, "-control"); + cout << "buffer_size = " << buffer_size << endl; + + char* filename = argv[argc-1]; + int argc1 = 0; + const char* argv1[64]; + for (int i = 1; i < argc-1; i++) { + if (string(argv[i]) == "-control") { + continue; + } else if (string(argv[i]) == "-bs") { + i++; + continue; + } + argv1[argc1++] = argv[i]; + } + + if (endWith(filename, "cmajor")) { + testCmajorPatch(filename, argc1, argv1); + } else { + testFaust(filename, argc1, argv1); + testCmajor(filename, argc1, argv1); + } + + return 0; +} diff -Nru faust-2.50.6+ds0/architecture/cmajor/cmajor-tools.h faust-2.54.9+ds0/architecture/cmajor/cmajor-tools.h --- faust-2.50.6+ds0/architecture/cmajor/cmajor-tools.h 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/cmajor/cmajor-tools.h 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,204 @@ +/************************** BEGIN cmajor-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 __cmajortools_dsp__ +#define __cmajortools_dsp__ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "faust/dsp/libfaust.h" + +/** + * Faust/Cmajor hybrid file parser + */ +class faust_cmajor_parser { + + private: + + std::map extractFaustBlocks(std::istream& in, std::stringstream& res_file) + { + std::string line; + std::stringstream faust_block; + bool is_faust_block = false; + int brackets = 0; + std::map faust_blocks; // name, code + std::map ::iterator cur_faust_block; + + while (getline(in, line)) { + + std::stringstream line_reader(line); + std::string token1, token2, token3; + + line_reader >> token1; + line_reader >> token2; + line_reader >> token3; + + if (is_faust_block) { + // End of block + if ((token1 == "}") && (--brackets == 0)) { + is_faust_block = false; + cur_faust_block->second = faust_block.str(); + faust_block.str(""); + // Start of block (or could be on the previous line) + } else if (token1 == "{") { + brackets++; + continue; + } else { + faust_block << line << "\n"; + } + continue; + } else { + is_faust_block = (token1 == "faust" && token2 != ""); + if (is_faust_block) { + if (token3 == "{") brackets++; + faust_blocks[token2] = ""; + cur_faust_block = faust_blocks.find(token2); + } + } + + // Keep the lines of Cmajor file + if (!is_faust_block) res_file << line << std::endl; + } + + return faust_blocks; + } + + std::string generateCmajorBlock(const std::string& name, const std::string& code, int argc, const char* argv[]) + { + int argc1 = 0; + const char* argv1[64]; + argv1[argc1++] = "-lang"; + //argv1[argc1++] = "cmajor"; + argv1[argc1++] = "cmajor-hybrid"; + argv1[argc1++] = "-cn"; + argv1[argc1++] = name.c_str(); + argv1[argc1++] = "-o"; + argv1[argc1++] = "/var/tmp/exp.cmajor"; + for (int i = 0; i < argc; i++) { + argv1[argc1++] = argv[i]; + } + argv1[argc1] = nullptr; // NULL terminated argv + + std::string error_msg; + bool res = generateAuxFilesFromString(name, code, argc1, argv1, error_msg); + + if (res) { + std::ifstream cmajor_file("/var/tmp/exp.cmajor"); + std::string cmajor_string((std::istreambuf_iterator(cmajor_file)), std::istreambuf_iterator()); + return cmajor_string; + } else { + std::cerr << "ERROR : generateAuxFilesFromFile " << error_msg; + return ""; + } + } + + public: + + faust_cmajor_parser() + {} + + ~faust_cmajor_parser() + {} + + bool parseCmajorFile(const std::string& input, const std::string& output, int argc, const char* argv[]) + { + std::ifstream reader(input.c_str()); + if (reader.is_open()) { + + // Open Cmajor output file + std::ofstream output_file(output); + + // Extract the Faust blocks and returns the input file without them + std::stringstream cmajor_file; + std::map faust_blocks = extractFaustBlocks(reader, cmajor_file); + + // Write all Faust blocks translated to Cmajor + for (const auto& it : faust_blocks) { + std::string block = generateCmajorBlock(it.first, it.second, argc, argv); + if (block == "") return false; + output_file << block; + } + + // Write the Cmajor part + output_file << cmajor_file.str(); + output_file.close(); + + return true; + } else { + return false; + } + } + + bool generateCmajorFile(const std::string& input, const std::string& output, int argc, const char* argv[]) + { + int argc1 = 0; + const char* argv1[64]; + argv1[argc1++] = "-lang"; + argv1[argc1++] = "cmajor"; + argv1[argc1++] = "-o"; + argv1[argc1++] = output.c_str(); + for (int i = 0; i < argc; i++) { + argv1[argc1++] = argv[i]; + } + argv1[argc1] = nullptr; // NULL terminated argv + + std::string error_msg; + bool res = generateAuxFilesFromFile(input, argc1, argv1, error_msg); + if (!res) { + std::cerr << "ERROR : generateAuxFilesFromFile " << error_msg; + } + return res; + } + + void createCmajorPatch(const std::string& cmajor_file) + { + // Generate "cmajorpatch" file + std::string cmajorpatch_file = cmajor_file + "patch"; + std::ofstream patch_file(cmajorpatch_file); + patch_file << "{" << std::endl; + patch_file << "\t\"CmajorVersion\": 1," << std::endl; + patch_file << "\t\"ID\": \"grame.cmajor.hybrid\"," << std::endl; + patch_file << "\t\"version\": \"1.0\"," << std::endl; + patch_file << "\t\"name\": \"hybrid\"," << std::endl; + patch_file << "\t\"description\": \"Cmajor example\"," << std::endl; + patch_file << "\t\"category\": \"synth\"," << std::endl; + patch_file << "\t\"manufacturer\": \"GRAME\"," << std::endl; + patch_file << "\t\"website\": \"https://faust.grame.fr\"," << std::endl; + patch_file << "\t\"isInstrument\": true," << std::endl; + patch_file << "\t\"source\": "; patch_file << "\"" << cmajor_file << "\"" << std::endl; + patch_file << "}"; + patch_file.close(); + } + +}; + +#endif +/************************** END cmajor-dsp.h **************************/ diff -Nru faust-2.50.6+ds0/architecture/cmajor/hybrid-test1.cmajor faust-2.54.9+ds0/architecture/cmajor/hybrid-test1.cmajor --- faust-2.50.6+ds0/architecture/cmajor/hybrid-test1.cmajor 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/cmajor/hybrid-test1.cmajor 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,100 @@ + +faust addSynth +{ + import("stdfaust.lib"); + + vol = hslider("volume [unit:dB]", -20, -96, 0, 0.1) : ba.db2linear : si.smoo; + freq = hslider("freq [unit:Hz]", 500, 100, 2000, 1); + + process = vgroup("addSynth", (os.osc(freq) + 0.5*os.osc(2.*freq) + 0.25*os.osc(3.*freq)) * vol); +} + +processor ClassicRingtone +{ + output stream float out; + + // This simple struct holds a note + duration for our melody + struct Note + { + int pitch, length; + + void play() const + { + let numFrames = this.length * framesPerQuarterNote; + let frequency = std::notes::noteToFrequency (this.pitch); + let phaseDelta = float (frequency * processor.period * twoPi); + + loop (numFrames) + { + out <- volume * sin (phase); + phase = addModulo2Pi (phase, phaseDelta); + advance(); + } + } + } + + // This is our processor's entry-point function, which is invoked + // by the system + void main() + { + let melody = Note[] ( (79, 1), (77, 1), (69, 2), (71, 2), + (76, 1), (74, 1), (65, 2), (67, 2), + (74, 1), (72, 1), (64, 2), (67, 2), + (72, 4) ); + + for (wrap i) + melody[i].play(); + } + + // We'll define a couple of constants here to set the volume and tempo + let volume = 0.15f; + let framesPerQuarterNote = int (processor.frequency / 7); + + float phase; +} + +faust stereoEcho +{ + import("stdfaust.lib"); + + gain = hslider("gain", 0.5, 0, 1, 0.01); + feedback = hslider("feedback", 0.8, 0, 1, 0.01); + + echo(del_sec, fb, g) = + ~ de.delay(50000, del_samples) * fb * g + with { + del_samples = del_sec*ma.SR; + }; + + process = echo(1.6, 0.6, 0.7), echo(0.7, feedback, gain); +} + +graph sequence [[main]] +{ + // Events to control Faust Synth + input event float32 freq [[ name: "freq", path: "/addSynth/freq", min: 100.0f, max: 2000.0f, init: 500.0f, step: 0.01f, unit: "Hz" ]]; + input event float32 volume [[ name: "volume", path: "/addSynth/volume", min: -96.0f, max: 0.0f, init: -20.0f, step: 0.100000001f, unit: "dB" ]]; + + // Events to control Faust Echo + input event float32 gain [[ name: "gain", path: "/stereoEcho/gain", min: 0.0f, max: 1.0f, init: 0.5, step: 0.01f ]]; + input event float32 feedback [[ name: "feedback", path: "/stereoEcho/feedback", min: 0.0f, max: 1.0f, init: 0.8, step: 0.01f ]]; + + output stream float audioOut0; + output stream float audioOut1; + + connection + { + // Connect to Faust addSynth + volume -> addSynth.volume; + freq -> addSynth.freq; + + // Connect to Faust stereoEcho + feedback -> stereoEcho.feedback; + gain -> stereoEcho.gain; + + addSynth.output0 -> stereoEcho.input0; + ClassicRingtone.out -> stereoEcho.input1; + + stereoEcho.output0 -> audioOut0; + stereoEcho.output1 -> audioOut1; + } +} diff -Nru faust-2.50.6+ds0/architecture/cmajor/hybrid-test1.cmajorpatch faust-2.54.9+ds0/architecture/cmajor/hybrid-test1.cmajorpatch --- faust-2.50.6+ds0/architecture/cmajor/hybrid-test1.cmajorpatch 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/cmajor/hybrid-test1.cmajorpatch 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,12 @@ +{ + "CmajorVersion": 1, + "ID": "grame.cmajor.hybrid-test1", + "version": "1.0", + "name": "hybrid-test1", + "description": "Cmajor example", + "category": "synth", + "manufacturer": "GRAME", + "website": "https://faust.grame.fr", + "isInstrument": false, + "source": "hybrid-test1.cmajor" +} \ No newline at end of file diff -Nru faust-2.50.6+ds0/architecture/cmajor/hybrid-test2.cmajor faust-2.54.9+ds0/architecture/cmajor/hybrid-test2.cmajor --- faust-2.50.6+ds0/architecture/cmajor/hybrid-test2.cmajor 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/cmajor/hybrid-test2.cmajor 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,60 @@ + +faust Osc +{ + import("stdfaust.lib"); + freq = hslider("freq [cmajor:osc_freq]", 300, 200, 2000, 0.1); + vol = hslider("vol", 0.5, 0, 1, 0.01); + process = os.osc(freq) * vol <: (_,_); +} + +faust Reverb +{ + import("stdfaust.lib"); + process = dm.freeverb_demo; +} + +processor Gain +{ + input event float volume [[ name: "Gain", min: 0, max: 1, init: 0.1, step: 0.01 ]]; + + input stream float input0; + input stream float input1; + + output stream float output0; + output stream float output1; + + event volume (float val) { vol = val; } + + float vol; + + void main() + { + loop { + output0 <- input0 * vol; + output1 <- input1 * vol; + advance(); + } + } +} + +graph Sequence [[main]] +{ + input Osc.osc_freq; + input Osc.vol; + input Gain.volume; + + output stream float audioOut0; + output stream float audioOut1; + + connection + { + Osc.output0 -> Reverb.input0; + Osc.output1 -> Reverb.input1; + + Reverb.output0 -> Gain.input0; + Reverb.output1 -> Gain.input1; + + Gain.output0 -> audioOut0; + Gain.output1 -> audioOut1; + } +} diff -Nru faust-2.50.6+ds0/architecture/cmajor/hybrid-test2.cmajorpatch faust-2.54.9+ds0/architecture/cmajor/hybrid-test2.cmajorpatch --- faust-2.50.6+ds0/architecture/cmajor/hybrid-test2.cmajorpatch 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/cmajor/hybrid-test2.cmajorpatch 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,12 @@ +{ + "CmajorVersion": 1, + "ID": "grame.cmajor.hybrid-test2", + "version": "1.0", + "name": "hybrid-test2", + "description": "Cmajor example", + "category": "synth", + "manufacturer": "GRAME", + "website": "https://faust.grame.fr", + "isInstrument": false, + "source": "hybrid-test2.cmajor" +} \ No newline at end of file diff -Nru faust-2.50.6+ds0/architecture/cmajor/Makefile faust-2.54.9+ds0/architecture/cmajor/Makefile --- faust-2.50.6+ds0/architecture/cmajor/Makefile 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/cmajor/Makefile 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,29 @@ + +FAUST ?= faust +LIB ?= $(shell $(FAUST) -libdir) +DESTDIR ?= +PREFIX ?= /usr/local +MACOSLIBS := -framework CoreAudio -framework AudioUnit -framework CoreServices -framework CoreMIDI -framework CoreFoundation + +prefix := $(DESTDIR)$(PREFIX) + +all: cmajor-faust-player cmajor-faust-tester cmajor-faust-editor + +cmajor-faust-player: cmajor-faust-player.cpp + c++ cmajor-faust-player.cpp -std=c++17 -O3 -I /usr/local/include -I /opt/local/include/gtk-2.0 -I `pkg-config --cflags --libs samplerate gtk+-2.0 jack` $(MACOSLIBS) $(LIB)/libfaust.a `llvm-config --ldflags --libs all --system-libs` -o cmajor-faust-player + #c++ cmajor-faust-player.cpp -std=c++17 -g -I /usr/local/include -I /opt/local/include/gtk-2.0 -I `pkg-config --cflags --libs samplerate gtk+-2.0 jack` $(MACOSLIBS) -lfaust -o cmajor-faust-player + +cmajor-faust-tester: cmajor-faust-tester.cpp + c++ cmajor-faust-tester.cpp -std=c++17 -O3 -I /usr/local/include $(LIB)/libfaust.a `llvm-config --ldflags --libs all --system-libs` -o cmajor-faust-tester + #c++ cmajor-faust-tester.cpp -std=c++17 -O3 -I /usr/local/include $(LIB)/libfaust.a `llvm-config --ldflags --libs all --system-libs` -o cmajor-faust-tester + +cmajor-faust-editor: cmajor-faust-editor.cpp cmajor-tools.h + c++ cmajor-faust-editor.cpp -std=c++17 -O3 -I /usr/local/include $(LIB)/libfaust.a libefsw-static-release.a $(MACOSLIBS) `llvm-config --ldflags --libs all --system-libs` -o cmajor-faust-editor + +install: + ([ -e cmajor-faust-player ]) && cp cmajor-faust-player $(prefix)/bin || echo cmajor-faust-player not found + ([ -e cmajor-faust-tester ]) && cp cmajor-faust-tester $(prefix)/bin || echo cmajor-faust-tester not found + ([ -e cmajor-faust-editor ]) && cp cmajor-faust-editor $(prefix)/bin || echo cmajor-faust-editor not found + +clean: + rm -f cmajor-faust-player cmajor-faust-tester cmajor-faust-editor diff -Nru faust-2.50.6+ds0/architecture/cmajor/minimal.cmajor faust-2.54.9+ds0/architecture/cmajor/minimal.cmajor --- faust-2.50.6+ds0/architecture/cmajor/minimal.cmajor 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/cmajor/minimal.cmajor 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,43 @@ +/************************************************************************ + 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 minimal.cmajor ****************/ + +/************************************************************************ + 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 . + + 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. + + ************************************************************************ + ************************************************************************/ + + <> +//---------------------------------------------------------------------------- +// FAUST generated signal processor +//---------------------------------------------------------------------------- +<> + +// Nothing more for now + +/******************** END minimal.cmajor ****************/ diff -Nru faust-2.50.6+ds0/architecture/cmajor/poly-dsp.cmajor faust-2.54.9+ds0/architecture/cmajor/poly-dsp.cmajor --- faust-2.50.6+ds0/architecture/cmajor/poly-dsp.cmajor 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/cmajor/poly-dsp.cmajor 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,103 @@ +/************************************************************************ + 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 poly-dsp.cmajor ****************/ + +/************************************************************************ + 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 . + + 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. + + ************************************************************************ + ************************************************************************/ + + <> +//---------------------------------------------------------------------------- +// FAUST generated signal processor +//---------------------------------------------------------------------------- +<> + +/* + Connect the wrapper with the real processor. + This indirection is done since the "expose control event" model is not yet in place. + So we have some 'ad-hoc' code for now that may change in the future +*/ +graph dsp_voice +{ + input event (std::notes::NoteOn, + std::notes::NoteOff, + std::notes::PitchBend) eventIn; + + output stream float audioOut0; + output stream float audioOut1; + + event eventIn (std::notes::NoteOn e) + { + mydsp.event_freq <- std::notes::noteToFrequency (e.pitch); + mydsp.event_gain <- e.velocity; + mydsp.event_gate <- 1.0f; + } + + event eventIn (std::notes::NoteOff e) + { + mydsp.event_gate <- 0.0f; + } + + event eventIn (std::notes::PitchBend e) + { + // TODO + } + + connection + { + mydsp.output0 -> audioOut0; + mydsp.output1 -> audioOut1; + } +} + +// Allocates voices, does dynamic voice management, connect to MIDI parser +graph mydsp_poly [[ main ]] +{ + input event std::midi::Message midiIn; + output stream float audioOut0; + output stream float audioOut1; + + node + { + midiParser = std::midi::MPEConverter; + voices = dsp_voice[NVOICES]; + voiceAllocator = std::voices::VoiceAllocator (NVOICES); + } + + connection + { + midiIn -> midiParser -> voiceAllocator -> voices; + + // Sum the voices audio out to the output + voices.audioOut0 -> audioOut0; + voices.audioOut1 -> audioOut1; + } +} + +/******************** END poly-dsp.cmajor ****************/ \ No newline at end of file diff -Nru faust-2.50.6+ds0/architecture/cmajor/poly-dsp-effect.cmajor faust-2.54.9+ds0/architecture/cmajor/poly-dsp-effect.cmajor --- faust-2.50.6+ds0/architecture/cmajor/poly-dsp-effect.cmajor 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/cmajor/poly-dsp-effect.cmajor 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,107 @@ +/************************************************************************ + 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 poly-dsp-effect.cmajor ****************/ + +/************************************************************************ + 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 . + + 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. + + ************************************************************************ + ************************************************************************/ + + <> +//---------------------------------------------------------------------------- +// FAUST generated signal processor +//---------------------------------------------------------------------------- +<> + +/* + Connect the wrapper with the real processor. + This indirection is done since the "expose control event" model is not yet in place. + So we have some 'ad-hoc' code for now that may change in the future +*/ +graph dsp_voice +{ + input event (std::notes::NoteOn, + std::notes::NoteOff, + std::notes::PitchBend) eventIn; + + output stream float audioOut0; + output stream float audioOut1; + + event eventIn (std::notes::NoteOn e) + { + mydsp.event_freq <- std::notes::noteToFrequency (e.pitch); + mydsp.event_gain <- e.velocity; + mydsp.event_gate <- 1.0f; + } + + event eventIn (std::notes::NoteOff e) + { + mydsp.event_gate <- 0.0f; + } + + event eventIn (std::notes::PitchBend e) + { + // TODO + } + + connection + { + mydsp.output0 -> audioOut0; + mydsp.output1 -> audioOut1; + } +} + +// Allocates voices, does dynamic voice management, connect to MIDI parser +graph mydsp_poly_effect [[ main ]] +{ + input event std::midi::Message midiIn; + output stream float audioOut0; + output stream float audioOut1; + + node + { + midiParser = std::midi::MPEConverter; + voices = dsp_voice[NVOICES]; + voiceAllocator = std::voices::VoiceAllocator (NVOICES); + } + + connection + { + midiIn -> midiParser -> voiceAllocator -> voices; + + // Sum the voices audio out to the effect + voices.audioOut0 -> effect.input0; + voices.audioOut1 -> effect.input1; + + // Connect the effect to the output + effect.output0 -> audioOut0; + effect.output1 -> audioOut1; + } +} + +/******************** END poly-dsp-effect.cmajor ****************/ diff -Nru faust-2.50.6+ds0/architecture/cmajor/README.md faust-2.54.9+ds0/architecture/cmajor/README.md --- faust-2.50.6+ds0/architecture/cmajor/README.md 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/cmajor/README.md 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,163 @@ +# faust2cmajor + +The **faust2cmajor** tool compiles a Faust DSP program in a folder containing the Cmajor source code and Cmajor patch. The result can be a monophonic DSP or a MIDI controllable polyphonic one (when the DSP describes an instrument, following the `freq, gain, gate` [parameter naming convention](https://faust.grame.fr/doc/manual/index.html#midi-polyphony-support)). The resulting Cmajor code can be played using the **cmaj** runtime: + +`faust2cmajor [-midi] [-nvoices ] [-effect auto|] [-juce] [-dsp] [-play] [additional Faust options (-cn foo -double...)] ` + +Here are the available options: + +- `-midi to activate MIDI control` +- `-nvoices to produce a polyphonic self-contained DSP with voices, ready to be used with MIDI` +- `-effect to produce a polyphonic DSP connected to a global output effect, ready to be used with MIDI` +- `-effect auto to produce a polyphonic DSP connected to a global output effect defined as 'effect' in , ready to be used with MIDI` +- `-juce to create a JUCE project` +- `-dsp to create a 'dsp' compatible subclass` +- `-test to test the resulting patch with 'cmaj render'` +- `-play to start the 'cmaj' runtime with the generated Cmajor patch` + +So for instance: + +- `faust2cmajor noise.dsp` to produce two noise.cmajor and noise.cmajorpatch files +- `faust2cmajor -play osc.dsp` to produce two osc.cmajor and osc.cmajorpatch files and play the osc.cmajorpatch +- `faust2cmajor -midi -nvoices 16 -play clarinetMIDI.dsp` to produce a 16 voices polyphonic MIDI aware intrument as two clarinetMIDI.cmajor and clarinetMIDI.cmajorpatch files and play the clarinetMIDI.cmajorpatch +- `faust2cmajor -midi -nvoices 16 -effect freeverb.dsp -play violinMIDI.dsp` to produce a 16 voices polyphonic MIDI aware intrument with a global effect as two violinMIDI.cmajor and violinMIDI.cmajorpatch files and play the violinMIDI.cmajorpatch + +# cmajor-faust-player + +The **cmajor-faust-player** tool loads a Faust DSP file, a Cmajor patch or an hybrid Faust/Cmajor code file, wraps it as a Faust DSP object, and runs it in the Faust runtime audio/control machinery. + +`cmajor-faust-player (pure Faust code), (pure Cmajor patch) or (pure Cmajor code or Faust/Cmajor hybrid code)` + +So for instance: + +- `faust2cmajor clarinetMIDI.dsp` to produce the two `clarinetMIDI.cmajor` and `clarinetMIDI.cmajorpatch` files + +Then: + +- `cmajor-faust-player clarinetMIDI.dsp` to run the `clarinetMIDI.dsp` file (only containing Faust code) +- `cmajor-faust-player clarinetMIDI.cmajorpatch` to run the `clarinetMIDI.cmajorpatch` file + +Or: + +- `cmajor-faust-player clarinetMIDI.cmajor` to run the `clarinetMIDI.cmajor` file (only containing the Cmajor code) +- `cmajor-faust-player hybrid-test1.cmajor` to run an hybrid `hybrid-test1.cmajor` file containing both Faust and Cmajor sections. Two `hybrid.cmajor` (containing the original Cmajor sections and the Faust => Cmajor generated sections) and an `hybrid.cmajorpatch` files will be generated in the process. + +# cmajor-faust-tester + +The **cmajor-faust-tester** tool allows to test DSP CPU usage of Faust and Cmajor programs, dynamically compiling them, and running them in the Faust runtime or **cmajor** runtime. It measures the DSP CPU usage as MBytes/sec and % of audio bandwidth at 44.1 kHz. + +`cmajor-faust-tester [-bs ] [-control] [Faust options : any option (e.g. -vec -vs 8...)] ` + +Here are the available options: + +- `-bs to set the maximum buffer-size in frames` +- `-control to update all controllers with random values at each cycle` + +So for instance: + +- `cmajor-faust-tester foo.dsp` to test 1) the Faust DSP code compiled to LLVM-IR and JITted to native code, then running in the Faust runtime, 2) the Faust DSP code compiled to Cmajor, then compiled to LLVM-IR and JITted to native code, and running in the **cmajor** runtime. + +- `cmajor-faust-tester foo.cmajorpatch` to test a Cmajor patch compiled to LLVM-IR and JITted to native code, and running in the **cmajor** runtime. + +# cmajor-faust-editor + +The **cmajor-faust-editor** tool loads an hybrid Faust/Cmajor code file and compiles it in a Cmajor patch each time the source file content changes. It can be used together with the **cmajor** runtime or any Cmajor aware plugin to create a *Faust/Cmajor => Cmajor => executable code* edit loop. The Cmajor generated files can be set using the`-o ` option and are named `hybrid.cmajor` and `hybrid.cmajorpatch` by default. + +`cmajor-faust-editor [Faust options : any option (e.g. -ftz 1...)] -o ` + +So for instance to setup a Faust/Cmajor hybrid file edition session: + +- `cmajor-faust-editor hybrid-test2.cmajor` to start editing an hybrid Faust/Cmajor code +- `cmaj play hybrid.cmajorpatch` to play the Cmajor dynamically generated `hybrid.cmajorpatch` + +## Hybrid Faust/Cmajor Syntax + +A Faust block uses the following syntax: + + ``` +faust Name +{ + ... Faust code... +} + ``` + +It will be compiled in Cmajor code as a `processor Name { ...Cmajor code... } ` and inserted back in the resulting Cmajor file. Here is a real example: + + ``` +faust Osc +{ + import("stdfaust.lib"); + freq = hslider("freq [cmajor:osc_freq]", 300, 200, 2000, 0.1); + vol = hslider("vol", 0.5, 0, 1, 0.01); + process = os.osc(freq) * vol <: (_,_); +} + ``` + + By convention, Faust processors audio inputs are numbered `input0/input1..inputN` and audio outputs `output0/output1..outputN`. So a given `faust Foo {...}` block can be used in the graph section with: `Foo.input0`, `Foo.input1`, `Foo.ouput0`, `Foo.output1` for instance. + +Control parameters (button, slider, nentry) are using their label name, or a possible *alias* if the `[cmajor:alias]` metadata appears in the label string. + +## Example of an hybrid file + +The following example combines: + +- an `Osc` Faust block with *freq (using an 'osc_freq' alias)* and *vol* controllers +- a `Gain` Cmajor processor with a *volume* controller +- a `Sequence` graph connecting the Faust osc in the Cmajor gain and exposing the three controllers + + ``` +faust Osc +{ + import("stdfaust.lib"); + freq = hslider("freq [cmajor:osc_freq]", 300, 200, 2000, 0.1); + vol = hslider("vol", 0.5, 0, 1, 0.01); + process = os.osc(freq) * vol <: (_,_); +} + +processor Gain +{ + input stream float volume [[ name: "Gain", min: 0, max: 1, init: 0.1, step: 0.01 ]]; + + input stream float input0; + input stream float input1; + + output stream float output0; + output stream float output1; + + void main() + { + loop + { + output0 <- input0 * volume; + output1 <- input1 * volume; + advance(); + } + } +} + +graph Sequence [[main]] +{ + // Used in 'hslider' label with [cmajor:osc_freq] metadata in 'Faust Osc {...}' block + input Osc.osc_freq; + // Used as 'hslider' label in 'Faust Osc {...}' block + input Osc.vol; + // Using in Cmajor 'processor Gain {...}' block + input Gain.volume; + + output stream float audioOut0; + output stream float audioOut1; + + connection + { + // Faust Osc {...} audio outputs are output0/output1...outputN + Osc.output0 -> Gain.input0; + Osc.output1 -> Gain.input1; + + Gain.output0 -> audioOut0; + Gain.output1 -> audioOut1; + } +} + ``` + +**Note**: the code has a dependency with the [efsw](https://github.com/havoc-io/efsw) library which has to be installed before compilation. + diff -Nru faust-2.50.6+ds0/architecture/cmajor/Using-Faust-in-Cmajor.md faust-2.54.9+ds0/architecture/cmajor/Using-Faust-in-Cmajor.md --- faust-2.50.6+ds0/architecture/cmajor/Using-Faust-in-Cmajor.md 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/cmajor/Using-Faust-in-Cmajor.md 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,194 @@ + + +# Using Faust in Cmajor + +In this tutorial, we present how [Faust](https://faust.grame.fr) can be used with [Cmajor](https://cmajor.dev), a C like procedural high-performance language especially designed for audio processing, and with dynamic JIT based compilation. Compiling Faust DSP to cmajor code will allow to take profit of hundreds of DSP building blocks implemented in the [Faust Libraries](https://faustlibraries.grame.fr), ready to use [Examples](https://faustdoc.grame.fr/examples/ambisonics/), any DSP program developed in more than 120 projects listed in the [Powered By Faust](https://faust.grame.fr/community/made-with-faust/) page, or Faust DSP programs found on the net. + +#### Who is this tutorial for? + +The [first section](#using-command-line-tools) assumes a working [Faust](https://github.com/grame-cncm/faust) compiler installed on the machine, so is more designed for regular Faust users. The [second section](#using-the-faust-web-ide) is better suited for Cmajor users who want to discover Faust. + +#### Installing the required packages + +Download the [**cmaj** package](https://github.com/SoundStacks/cmajor/releases) and install to have it in your PATH. + +## Using command line tools + +### Generating Cmajor code + +Assuming you've [compiled and installed the **faust** compiler](https://github.com/grame-cncm/faust/wiki/BuildingSimple), starting from the following DSP **osc.dsp** program: + + +``` +import("stdfaust.lib"); + +vol = hslider("volume [unit:dB]", 0, -96, 0, 0.1) : ba.db2linear : si.smoo; +freq1 = hslider("freq1 [unit:Hz]", 1000, 20, 3000, 1); +freq2 = hslider("freq2 [unit:Hz]", 200, 20, 3000, 1); + +process = vgroup("Oscillator", os.osc(freq1) * vol, os.osc(freq2) * vol); +``` + + +The Cmajor code can be generated using: + +```bash +faust -lang cmajor osc.dsp -o osc.cmajor +``` + +This will generate a `mydsp` processor with a set of methods to manipulate it. This API basically mimics the [one defined for the C++ backend](https://github.com/grame-cncm/faust/blob/master-dev/architecture/faust/dsp/dsp.h). + +### Looking at the generated code + +The generated code contains `input event` definition for the three sliders defined in the DSP source code: + +``` +input event float32 eventfHslider1 [[ name: "freq1", group: "/v:Oscillator/freq1", min: 20.0f, max: 3000.0f, init: 1000.0f, step: 1.0f, meta_unit0: "Hz" ]]; +input event float32 eventfHslider2 [[ name: "freq2", group: "/v:Oscillator/freq2", min: 20.0f, max: 3000.0f, init: 200.0f, step: 1.0f, meta_unit1: "Hz" ]]; +input event float32 eventfHslider0 [[ name: "volume", group: "/v:Oscillator/volume", min: 0.0f, max: 1.0f, init: 0.5f, step: 0.01f ]]; +``` + +The needed `main` function executes the DSP sample generation code: + +``` +void main() +{ + // DSP loop running forever... + loop + { + if (fUpdated) { fUpdated = false; control(); } + + // Computes one sample + fRec1[0] = fControl[1] + fRec1[1] - floor (fControl[1] + fRec1[1]); + output0 <- float32 (fControl[0] * ftbl0mydspSIG0.at (int32 (65536.0f * fRec1[0]))); + fRec2[0] = fControl[2] + fRec2[1] - floor (fControl[2] + fRec2[1]); + output1 <- float32 (fControl[0] * ftbl0mydspSIG0.at (int32 (65536.0f * fRec2[0]))); + fRec1[1] = fRec1[0]; + fRec2[1] = fRec2[0]; + + // Moves all streams forward by one 'tick' + advance(); + } +} +``` + +Note that the generated code uses the so-called [scalar code generation model](https://faustdoc.grame.fr/manual/compiler/#structure-of-the-generated-code), the default one, where the compiled sample generation code is inlined on the Cmajor `loop` block. + +The resulting file is self-contained and so can directly be compiled and executed using the **cmaj** program: + +```bash +cmaj play osc.cmajor +``` + +The three declared sliders are automatically created and can be used to change the two channels frequencies and their volume. + +The Cmajor processor code can directly be used in a more complex Cmajor program, possibly connected to other Faust generated or Cmajor hand-written processors. Note that the generated processor name can simply be changed using the Faust compiler `-cn ` option, so that several Faust generated processors can be distinguished by their names: + +```bash +faust -lang cmajor -cn osc osc.dsp -o osc.cmajor +``` + +### Using the faust2cmajor tool + +The [faust2cmajor](https://github.com/SoundStacks/faust/tree/cmajor/architecture/cmajor#faust2cmajor) tool allows to automate calling the Faust compiler with the right options and interacting with the **cmaj** program: + +```bash +faust2cmajor -h +Usage: faust2cmajor [options] [Faust options] +Compiles Faust programs to Cmajor +Options: + -midi : activates MIDI control + -nvoices : produces a polyphonic DSP with voices, ready to be used with MIDI events + -effect : generates a polyphonic DSP connected to a global output effect, ready to be used with MIDI or OSC + -effect auto : generates a polyphonic DSP connected to a global output effect defined as 'effect' in , ready to be used with MIDI or OSC + -juce : to create a JUCE project + -dsp : to create a 'dsp' compatible subclass + -play : to start the 'cmaj' runtime with the generated Cmajor file + Faust options : any option (e.g. -vec -vs 8...). See the Faust compiler documentation. +``` + +So the following command: +```bash +faust2cmajor -play osc.dsp +``` + +Will directly compile the `osc.dsp` file, generate the `osc.cmajor` and `osc.cmajorpatch` files: + +``` +{ + "CmajorVersion": 1, + "ID": "grame.cmajor.osc", + "version": "1.0", + "name": "osc", + "description": "Cmajor example", + "category": "synth", + "manufacturer": "GRAME", + "website": "https://faust.grame.fr", + "isInstrument": false, + "source": "osc.cmajor" +} +``` + +And activate the **cmaj** program to run the processor. + +The following [polyphonic ready instrument](https://faustdoc.grame.fr/manual/midi/#midi-polyphony-support) DSP can be converted to a MIDI ready cmajor instrument: + + +``` +import("stdfaust.lib"); +process = organ, organ +with { + decimalpart(x) = x-int(x); + phasor(f) = f/ma.SR : (+ : decimalpart) ~ _; + osc(f) = sin(2 * ma.PI * phasor(f)); + freq = nentry("freq", 100, 100, 3000, 0.01); + gate = button("gate"); + gain = nentry("gain", 0.5, 0, 1, 0.01); + organ = gate * (osc(freq) * gain + osc(2 * freq) * gain); +}; +``` + + +The following command then opens the **cmaj** program and MDI events can be sent to control the instrument: +```bash +faust2cmajor -play -midi -nvoices 16 organ.dsp +``` + +Note that the generated GUI is empty, since the generated processor cannot automatically reflects its controls in the main graph. + +The following [polyphonic ready instrument](https://faustdoc.grame.fr/manual/midi/#audio-effects-and-polyphonic-synthesizer) DSP, with an integrated effect, can be converted to a MIDI ready cmajor instrument: + + +``` +import("stdfaust.lib"); +process = pm.clarinet_ui_MIDI <: _,_; +effect = dm.freeverb_demo; +``` + + +The following command then opens the **cmaj** program and MDI events can be sent to control the instrument: +```bash +faust2cmajor -play -midi -nvoices 16 -effect auto clarinet.dsp +``` + +Here again the generated GUI is empty. + +## Using the Faust Web IDE + +Faust DSP program can be written, tested in the [Faust Web IDE](https://faustide.grame.fr/) and generated as embeddable Cmajor code. + +### Generating the Cmajor output + +The output as a Cmajor program can directly be generated using the *Platform = source* and *Architecture = cmajor* export options. The resulting *foo* folder is self-contained, containing the `foo.cmajor` and `foo.cmajorpatch` files. The program can be executed using `cmaj play foo/foo.cmajorpatch` command or possibly [converted as a JUCE plugin](https://github.com/SoundStacks/cmajor/blob/main/docs/Getting%20Started.md#generating-c-and-wasm-code). + +

+*Exporting the code* + +### Generating the Cmajor output in polyphonic mode + +DSP programs following the polyphonic [freq/gate/gain convention](https://faustdoc.grame.fr/manual/midi/#midi-polyphony-support) can be generated using the *Platform = source* and *Architecture = cmajor-poly* export options. The resulting *foo* folder is self-contained, containing the `foo.cmajor` and `foo.cmajorpatch` files. The instrument can be executed using `cmaj play foo/foo.cmajorpatch` command and played with a MIDI device or possibly [converted as a JUCE plugin](https://github.com/SoundStacks/cmajor/blob/main/docs/Getting%20Started.md#generating-c-and-wasm-code). + +### Generating the Cmajor output in polyphonic mode with a global effect + +DSP programs following the polyphonic [freq/gate/gain convention](https://faustdoc.grame.fr/manual/midi/#midi-polyphony-support) with and an [integrated effect](https://faustdoc.grame.fr/manual/midi/#audio-effects-and-polyphonic-synthesizer) can be generated using the *Platform = source* and *Architecture = cmajor-poly-effect* export options. The resulting *foo* folder is self-contained, containing the `foo.cmajor` and `foo.cmajorpatch` files. The instrument can be executed using `cmaj play foo/foo.cmajorpatch` command and played with a MIDI device or possibly [converted as a JUCE plugin](https://github.com/SoundStacks/cmajor/blob/main/docs/Getting%20Started.md#generating-c-and-wasm-code). + diff -Nru faust-2.50.6+ds0/architecture/cpal.rs faust-2.54.9+ds0/architecture/cpal.rs --- faust-2.50.6+ds0/architecture/cpal.rs 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/cpal.rs 2022-12-17 10:41:42.000000000 +0000 @@ -106,7 +106,17 @@ fn main() -> Result<(), anyhow::Error> { // Allocation DSP on the heap - let mut dsp = Box::new(mydsp::new()); + let mut dsp; + #[cfg(feature = "default-boxed")] + { + use default_boxed::DefaultBoxed; + dsp = mydsp::default_boxed(); + } + + #[cfg(not(feature = "default-boxed"))] + { + dsp = Box::new(mydsp::new()); + } println!("get_num_inputs: {}", dsp.get_num_inputs()); println!("get_num_outputs: {}", dsp.get_num_outputs()); diff -Nru faust-2.50.6+ds0/architecture/daisy/README.md faust-2.54.9+ds0/architecture/daisy/README.md --- faust-2.50.6+ds0/architecture/daisy/README.md 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/daisy/README.md 2022-12-17 10:41:42.000000000 +0000 @@ -6,7 +6,8 @@ Here are the available options: -- `-patch : to compile for 4 ins/outs Patch (TODO)` +- `-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 to produce a polyphonic self-contained DSP with voices, ready to be used with MIDI (TODO)` - `-sr to specify sample rate (default 44100)` diff -Nru faust-2.50.6+ds0/architecture/dplug.d faust-2.54.9+ds0/architecture/dplug.d --- faust-2.50.6+ds0/architecture/dplug.d 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/dplug.d 2022-12-17 10:41:42.000000000 +0000 @@ -36,6 +36,7 @@ import dplug.core.vec; import dplug.client; +import core.stdc.stdlib : strtol; alias FAUSTFLOAT = float; @@ -101,34 +102,53 @@ _faustParams = makeVec!FaustParam(); } + override void declare(FAUSTFLOAT* id, string key, string value) + { + if (value == "") + { + nextParamId = cast(int)strtol(key.ptr, null, 0); + } + else if (key == "unit") + { + nextParamUnit = value; + } + } + override void addButton(string label, FAUSTFLOAT* val) { - _faustParams.pushBack(FaustParam(label, val, 0, 0, 0, 0, true)); + _faustParams.pushBack(FaustParam(label, nextParamUnit, val, 0, 0, 0, 0, true, nextParamId)); + resetNextParamMeta(); } override void addCheckButton(string label, FAUSTFLOAT* val) { - _faustParams.pushBack(FaustParam(label, val, 0, 0, 0, 0, true)); + _faustParams.pushBack(FaustParam(label, nextParamUnit, val, 0, 0, 0, 0, true, nextParamId)); + resetNextParamMeta(); } override void addVerticalSlider(string label, FAUSTFLOAT* val, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) { - _faustParams.pushBack(FaustParam(label, val, init, min, max, step)); + _faustParams.pushBack(FaustParam(label, nextParamUnit, val, init, min, max, step, false, nextParamId)); + resetNextParamMeta(); } override void addHorizontalSlider(string label, FAUSTFLOAT* val, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) { - _faustParams.pushBack(FaustParam(label, val, init, min, max, step)); + _faustParams.pushBack(FaustParam(label, nextParamUnit, val, init, min, max, step, false, nextParamId)); + resetNextParamMeta(); } override void addNumEntry(string label, FAUSTFLOAT* val, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) { - _faustParams.pushBack(FaustParam(label, val, init, min, max, step)); + _faustParams.pushBack(FaustParam(label, nextParamUnit, val, init, min, max, step, false, nextParamId)); + resetNextParamMeta(); } FaustParam[] readParams() { - return _faustParams.releaseData(); + /* return _faustParams.releaseData(); */ + /* Vec!FaustParam _sortedList = makeVec!FaustParam(); */ + return sortParams(_faustParams.releaseData()); } FaustParam readParam(int index) @@ -142,25 +162,59 @@ } private: - Vec!FaustParam _faustParams; + Vec!FaustParam _faustParams; + int nextParamId = -1; + string nextParamUnit = ""; + + void resetNextParamMeta() + { + nextParamId = -1; + nextParamUnit = ""; + } + + // simple bubble sort + FaustParam[] sortParams(FaustParam[] params) + { + bool success = true; + do + { + success = true; + for(int i = 0; i < params.length - 1; ++i) + { + auto left = params[i]; + auto right = params[i + 1]; + if (right.ParamId < left.ParamId) + { + params[i] = right; + params[i + 1] = left; + success = false; + } + } + } + while(!success); + return params; + } } struct FaustParam { - string label; - FAUSTFLOAT* val; - FAUSTFLOAT initial; - FAUSTFLOAT min; - FAUSTFLOAT max; - FAUSTFLOAT step; + string label; + string unit; + FAUSTFLOAT* val; + FAUSTFLOAT initial; + FAUSTFLOAT min; + FAUSTFLOAT max; + FAUSTFLOAT step; bool isButton = false; + int ParamId; } version(unittest){} +version(faustoverride){} else mixin(pluginEntryPoints!FaustClient); -final class FaustClient : dplug.client.Client +class FaustClient : dplug.client.Client { public: nothrow: @@ -200,13 +254,16 @@ int faustParamIndexStart = 0; foreach(param; _faustParams) { - if(param.isButton) + if (param.isButton) { params ~= mallocNew!BoolParameter(faustParamIndexStart++, param.label, cast(bool)(*param.val)); } + else if (param.step == 1.0f) { + params ~= mallocNew!IntegerParameter(faustParamIndexStart++, param.label, param.unit, cast(int)param.min, cast(int)param.max, cast(int)param.initial); + } else { - params ~= mallocNew!LinearFloatParameter(faustParamIndexStart++, param.label, param.label, param.min, param.max, param.initial); + params ~= mallocNew!LinearFloatParameter(faustParamIndexStart++, param.label, param.unit, param.min, param.max, param.initial); } } @@ -216,10 +273,10 @@ override LegalIO[] buildLegalIO() { auto io = makeVec!LegalIO(); - if(_dsp is null) - { - _dsp = mallocNew!(FAUSTCLASS)(); - } + if (_dsp is null) + { + _dsp = mallocNew!(FAUSTCLASS)(); + } io ~= LegalIO(_dsp.getNumInputs(), _dsp.getNumOutputs()); return io.releaseData(); } @@ -249,17 +306,30 @@ assert(maxFrames <= 512); // guaranteed by audio buffer splitting } - // TODO: use parameter listeners to update the faust param values rather - // than force updating them on every process call void updateFaustParams() { foreach(param; params()) { foreach(faustParam; _faustParams) { - if(param.label() == faustParam.label) + if (param.label() == faustParam.label) { - *(faustParam.val) = (cast(FloatParameter)param).value(); + if (cast(FloatParameter)param) + { + *(faustParam.val) = (cast(FloatParameter)param).valueAtomic(); + } + else if (cast(IntegerParameter)param) + { + *(faustParam.val) = cast(FAUSTFLOAT)((cast(IntegerParameter)param).valueAtomic()); + } + else if (cast(BoolParameter)param) + { + *(faustParam.val) = cast(FAUSTFLOAT)((cast(BoolParameter)param).valueAtomic()); + } + else + { + assert(false, "Parameter type not implemented"); + } } } } diff -Nru faust-2.50.6+ds0/architecture/faust/dsp/cmajor-cpp-dsp.h faust-2.54.9+ds0/architecture/faust/dsp/cmajor-cpp-dsp.h --- faust-2.50.6+ds0/architecture/faust/dsp/cmajor-cpp-dsp.h 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/dsp/cmajor-cpp-dsp.h 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,233 @@ +/************************** BEGIN cmajor-cpp-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 __cmajor_cpp_dsp__ +#define __cmajor_cpp_dsp__ + +#include +#include +#include +#include +#include +#include + +#include "faust/dsp/dsp.h" +#include "faust/gui/UI.h" + +#include +#include + +// Generated with 'cmaj generate --target=cpp foo.cmajor --output=cmajordsp.h' +#include "cmajordsp.h" + +#define SESSION_ID 123456 + +/** +* Faust wrapped C++ Cmajor DSP +*/ +class cmajor_cpp_dsp : public dsp { + + private: + + cmajordsp fDSP; + int fSampleRate; + choc::value::Value fControllers; + FAUSTFLOAT* fZoneMap; + std::map> fZoneFunMap; + + bool startWith(const std::string& str, const std::string& prefix) + { + return (str.substr(0, prefix.size()) == prefix); + } + + void updateControls() + { + for (const auto& it : fZoneFunMap) { + it.second(*it.first); + } + } + + choc::com::String* getInputEndpoints() + { + return choc::com::createRawString(fDSP.inputEndpointDetailsJSON); + } + + public: + + cmajor_cpp_dsp() + { + // numInputEndpoints actually counts controllers and audio inputs + fZoneMap = new FAUSTFLOAT[fDSP.numInputEndpoints]; + fControllers = choc::json::parse(fDSP.inputEndpointDetailsJSON); + } + + virtual ~cmajor_cpp_dsp() + { + delete [] fZoneMap; + } + + virtual int getNumInputs() + { + return fDSP.numAudioInputChannels; + } + + virtual int getNumOutputs() + { + return fDSP.numAudioOutputChannels; + } + + virtual void buildUserInterface(UI* ui_interface) + { + ui_interface->openVerticalBox("CMajor"); + int i = 0; + for (const auto& it : fControllers) { + if (it.isObject() && it.hasObjectMember("endpointID")) { + std::string name = it["endpointID"].getWithDefault(""); + uint32_t index = fDSP.getEndpointHandleForName(name); + if (startWith(name, "eventfCheckbox")) { + ui_interface->addCheckButton(name.c_str(), &fZoneMap[i]); + fZoneMap[i] = 0; + fZoneFunMap[&fZoneMap[i]] = [=](FAUSTFLOAT value) { fDSP.addEvent(index, 0, &value); }; + i++; + } else if (startWith(name, "eventfButton")) { + ui_interface->addButton(name.c_str(), &fZoneMap[i]); + fZoneMap[i] = 0; + fZoneFunMap[&fZoneMap[i]] = [=](FAUSTFLOAT value) { fDSP.addEvent(index, 0, &value); }; + i++; + } else if (startWith(name, "eventfHslider")) { + FAUSTFLOAT min_v = it["annotation"]["min"].getWithDefault(0); + FAUSTFLOAT max_v = it["annotation"]["max"].getWithDefault(0); + FAUSTFLOAT init = it["annotation"]["init"].getWithDefault(0); + FAUSTFLOAT step = it["annotation"]["step"].getWithDefault(0); + ui_interface->addHorizontalSlider(name.c_str(), &fZoneMap[i], init, min_v, max_v, step); + fZoneMap[i] = init; + fZoneFunMap[&fZoneMap[i]] = [=](FAUSTFLOAT value) { fDSP.addEvent(index, 0, &value); }; + i++; + } else if (startWith(name, "eventfVslider")) { + FAUSTFLOAT min_v = it["annotation"]["min"].getWithDefault(0); + FAUSTFLOAT max_v = it["annotation"]["max"].getWithDefault(0); + FAUSTFLOAT init = it["annotation"]["init"].getWithDefault(0); + FAUSTFLOAT step = it["annotation"]["step"].getWithDefault(0); + ui_interface->addVerticalSlider(name.c_str(), &fZoneMap[i], init, min_v, max_v, step); + fZoneMap[i] = init; + fZoneFunMap[&fZoneMap[i]] = [=](FAUSTFLOAT value) { fDSP.addEvent(index, 0, &value); }; + i++; + } else if (startWith(name, "eventfEntry")) { + FAUSTFLOAT min_v = it["annotation"]["min"].getWithDefault(0); + FAUSTFLOAT max_v = it["annotation"]["max"].getWithDefault(0); + FAUSTFLOAT init = it["annotation"]["init"].getWithDefault(0); + FAUSTFLOAT step = it["annotation"]["step"].getWithDefault(0); + ui_interface->addNumEntry(name.c_str(), &fZoneMap[i], init, min_v, max_v, step); + fZoneMap[i] = init; + fZoneFunMap[&fZoneMap[i]] = [=](FAUSTFLOAT value) { fDSP.addEvent(index, 0, &value); }; + i++; + } else if (startWith(name, "eventfVbargraph")) { + FAUSTFLOAT min_v = it["annotation"]["min"].getWithDefault(0); + FAUSTFLOAT max_v = it["annotation"]["max"].getWithDefault(0); + ui_interface->addHorizontalBargraph(name.c_str(), &fZoneMap[i], min_v, max_v); + fZoneMap[i] = 0; + i++; + } else if (startWith(name, "eventfHbargraph")) { + FAUSTFLOAT min_v = it["annotation"]["min"].getWithDefault(0); + FAUSTFLOAT max_v = it["annotation"]["max"].getWithDefault(0); + ui_interface->addVerticalBargraph(name.c_str(), &fZoneMap[i], min_v, max_v); + fZoneMap[i] = 0; + i++; + } + } + } + ui_interface->closeBox(); + } + + virtual int getSampleRate() + { + return fSampleRate; + } + + virtual void init(int sample_rate) + { + fSampleRate = sample_rate; + fDSP.initialise(SESSION_ID, double(sample_rate)); + } + + virtual void instanceInit(int sample_rate) + { + fSampleRate = sample_rate; + fDSP.initialise(SESSION_ID, double(sample_rate)); + } + + virtual void instanceConstants(int sample_rate) + { + fSampleRate = sample_rate; + } + + virtual void instanceResetUserInterface() + {} + + virtual void instanceClear() + {} + + virtual cmajor_cpp_dsp* clone() + { + return new cmajor_cpp_dsp(); + } + + virtual void metadata(Meta* m) + {} + + void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) + { + // Copy audio inputs + if (fDSP.numAudioInputChannels > 0) { + for (int chan = 0; chan < fDSP.numAudioInputChannels; chan++) { + uint32_t index = fDSP.getEndpointHandleForName("input" + std::to_string(chan)); + fDSP.setInputFrames(index, inputs[chan], count, 0); + } + } + + // Update control + updateControls(); + + // Render + fDSP.advance(count); + + // Copy audio outputs + if (fDSP.numAudioOutputChannels > 0) { + for (int chan = 0; chan < fDSP.numAudioOutputChannels; chan++) { + int32_t index = fDSP.getEndpointHandleForName("output" + std::to_string(chan)); + fDSP.copyOutputFrames(index, outputs[chan], count); + } + } + } + + virtual void compute(double /*date_usec*/, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) + { + compute(count, inputs, outputs); + } + +}; + +#endif + +/************************** END cmajor-cpp-dsp.h **************************/ diff -Nru faust-2.50.6+ds0/architecture/faust/dsp/cmajorpatch-dsp.h faust-2.54.9+ds0/architecture/faust/dsp/cmajorpatch-dsp.h --- faust-2.50.6+ds0/architecture/faust/dsp/cmajorpatch-dsp.h 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/dsp/cmajorpatch-dsp.h 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,468 @@ +/************************** BEGIN cmajorpatch-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 __cmajorpatch_dsp__ +#define __cmajorpatch_dsp__ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "faust/dsp/dsp.h" +#include "faust/misc.h" +#include "faust/midi/midi.h" +#include "faust/gui/UI.h" + +class cmajor_dsp_factory; + +/** +* Faust wrapped Cmajor DSP +*/ +class cmajorpatch_dsp : public dsp { + + private: + + cmajor_dsp_factory* fFactory; + + cmaj::Performer fPerformer; + cmaj::EndpointDetailsList fEndpointInputs; + cmaj::EndpointDetailsList fEndpointOutputs; + int fNumInputs = 0; + int fNumOutputs = 0; + int fSampleRate; + FAUSTFLOAT* fZoneMap; + std::map> fInputsFunMap; + std::map> fOutputsFunMap; + + // MIDI handling + midi_handler* fMIDIHander; + + void updateInputControls() + { + for (const auto& it : fInputsFunMap) { + it.second(*it.first); + } + } + void updateOutputControls() + { + for (const auto& it : fOutputsFunMap) { + *it.first = it.second(); + } + } + + public: + + // Implemented later on + cmajorpatch_dsp(cmajor_dsp_factory* factory, std::string& error_msg); + + virtual ~cmajorpatch_dsp() + { + delete [] fZoneMap; + } + + void setMidiHandler(midi_handler* handler) { fMIDIHander = handler; } + midi_handler* getMidiHandler() { return fMIDIHander; } + + virtual int getNumInputs() + { + return fNumInputs; + } + + virtual int getNumOutputs() + { + return fNumOutputs; + } + + virtual void buildUserInterface(UI* ui_interface); + + virtual int getSampleRate() + { + return fSampleRate; + } + + void classInit(int sample_rate) + {} + + // Implemented later on + virtual void init(int sample_rate); + + virtual void instanceInit(int sample_rate) + { + instanceConstants(sample_rate); + instanceResetUserInterface(); + instanceClear(); + } + + virtual void instanceConstants(int sample_rate) + {} + + virtual void instanceResetUserInterface() + {} + + virtual void instanceClear() + {} + + // Implemented later on + virtual cmajorpatch_dsp* clone(); + + virtual void metadata(Meta* m) {} + + virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs); + + virtual void compute(double /*date_usec*/, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { compute(count, inputs, outputs); } + +}; + +/** + * Faust wrapped Cmajor patches factory + */ +class cmajor_dsp_factory : public dsp_factory { + + protected: + + friend cmajorpatch_dsp; + + cmaj::Engine fEngine; + std::vector fHandleInputs; + std::vector fHandleOutputs; + + std::map fHandleInputControls; + std::map fHandleOutputControls; + + public: + + cmajor_dsp_factory(const std::string& dsp_content, std::string& error_msg) + { + std::string filename = "/usr/local/lib/" + std::string(cmaj::Library::getDLLName()); + if (!cmaj::Library::initialise(filename)) { + error_msg = "ERROR : cannot load CMajor library\n"; + throw std::bad_alloc(); + } + + fEngine = cmaj::Engine::create(); + cmaj::DiagnosticMessageList messages; + cmaj::Program program; + if (!program.parse(messages, "", dsp_content)) { + error_msg = "ERROR : failed to parse : " + messages.toString() + "\n"; + throw std::bad_alloc(); + } + + cmaj::BuildSettings settings; + settings.setFrequency(44100); // Dummy value + settings.setSessionID(123456); + fEngine.setBuildSettings (settings); + + if (!fEngine.load(messages, program)) { + error_msg = "ERROR : failed to load : " + messages.toString() + "\n"; + throw std::bad_alloc(); + } + + /* + std::cout << "Input endpoints:" << std::endl + << fEngine.getInputEndpoints().getDescription() << std::endl + << std::endl + << "Output endpoints:" << std::endl + << fEngine.getOutputEndpoints().getDescription() << std::endl + << std::endl; + */ + + cmaj::EndpointDetailsList endpoint_inputs = fEngine.getInputEndpoints(); + cmaj::EndpointDetailsList endpoint_outputs = fEngine.getOutputEndpoints(); + + // Get control ins/outs handle + for (const auto& it : endpoint_inputs) { + std::string name = it.endpointID.toString(); + if (choc::text::startsWith(name, "eventfCheckbox") + || choc::text::startsWith(name, "eventfButton") + || choc::text::startsWith(name, "eventfHslider") + || choc::text::startsWith(name, "eventfVslider") + || choc::text::startsWith(name, "eventfEntry")) { + fHandleInputControls[name] = fEngine.getEndpointHandle(it.endpointID); + } + } + for (const auto& it : endpoint_outputs) { + std::string name = it.endpointID.toString(); + if (choc::text::startsWith(name, "eventfHbargraph") + || choc::text::startsWith(name, "eventfVbargraph")) { + fHandleOutputControls[name] = fEngine.getEndpointHandle(it.endpointID); + } + } + + // Get audio ins/outs handle + for (const auto& it : endpoint_inputs) { + if (it.isInput && it.getNumAudioChannels() > 0) { + fHandleInputs.push_back(fEngine.getEndpointHandle(it.endpointID)); + } + } + for (const auto& it : endpoint_outputs) { + if (!it.isInput && it.getNumAudioChannels() > 0) { + fHandleOutputs.push_back(fEngine.getEndpointHandle(it.endpointID)); + } + } + + if (!fEngine.link(messages)) { + std::cout << "Failed to link!" << std::endl + << messages.toString() << std::endl; + throw std::bad_alloc(); + } + } + + virtual ~cmajor_dsp_factory() {} + + virtual std::string getName() { + //return fDescription->name; + } + virtual std::string getSHAKey() { return ""; } + virtual std::string getDSPCode() { return ""; } + virtual std::string getCompileOptions() { return ""; } + virtual std::vector getLibraryList() { return {}; } + virtual std::vector getIncludePathnames() { return {}; } + virtual std::vector getWarningMessages() { return {}; } + + virtual cmajorpatch_dsp* createDSPInstance() + { + std::string error_msg; + return new cmajorpatch_dsp(this, error_msg); + } + + virtual void setMemoryManager(dsp_memory_manager* manager) {} + virtual dsp_memory_manager* getMemoryManager() { return nullptr; }; + +}; + +cmajorpatch_dsp::cmajorpatch_dsp(cmajor_dsp_factory* factory, std::string& error_msg) +{ + fFactory = factory; + fMIDIHander = nullptr; + + fPerformer = fFactory->fEngine.createPerformer(); + + fEndpointInputs = fFactory->fEngine.getInputEndpoints(); + fEndpointOutputs = fFactory->fEngine.getOutputEndpoints(); + + fZoneMap = new FAUSTFLOAT[fEndpointInputs.size() + fEndpointOutputs.size()]; + + // Get ins/outs number + for (const auto& it : fEndpointInputs) { + fNumInputs += it.getNumAudioChannels(); + } + for (const auto& it : fEndpointOutputs) { + fNumOutputs += it.getNumAudioChannels(); + } +} + +void cmajorpatch_dsp::init(int sample_rate) +{ + cmaj::BuildSettings settings; + settings.setFrequency(sample_rate); + settings.setSessionID(123456); + fFactory->fEngine.setBuildSettings(settings); +} + +void cmajorpatch_dsp::buildUserInterface(UI* ui_interface) +{ + ui_interface->openVerticalBox("CMajor"); + ui_interface->openVerticalBox("Inputs"); + int i = 0; + // Inputs + for (const auto& it : fEndpointInputs) { + std::string name = it.endpointID.toString(); + uint32_t index = fFactory->fEngine.getEndpointHandle(name.c_str()); + if (choc::text::startsWith(name, "eventfCheckbox")) { + ui_interface->addCheckButton(name.c_str(), &fZoneMap[i]); + fZoneMap[i] = 0; + fInputsFunMap[&fZoneMap[i]] = [=](FAUSTFLOAT value) { fPerformer.addInputEvent(fFactory->fHandleInputControls[name], 0, value); }; + i++; + } else if (choc::text::startsWith(name, "eventfButton")) { + ui_interface->addButton(name.c_str(), &fZoneMap[i]); + fZoneMap[i] = 0; + fInputsFunMap[&fZoneMap[i]] = [=](FAUSTFLOAT value) { fPerformer.addInputEvent(fFactory->fHandleInputControls[name], 0, value); }; + i++; + } else if (choc::text::startsWith(name, "eventfHslider")) { + FAUSTFLOAT min_v = it.annotation["min"].getWithDefault(0); + FAUSTFLOAT max_v = it.annotation["max"].getWithDefault(0); + FAUSTFLOAT init = it.annotation["init"].getWithDefault(0); + FAUSTFLOAT step = it.annotation["step"].getWithDefault(0); + ui_interface->addHorizontalSlider(name.c_str(), &fZoneMap[i], init, min_v, max_v, step); + fZoneMap[i] = init; + fInputsFunMap[&fZoneMap[i]] = [=](FAUSTFLOAT value) { fPerformer.addInputEvent(fFactory->fHandleInputControls[name], 0, value); }; + i++; + } else if (choc::text::startsWith(name, "eventfVslider")) { + FAUSTFLOAT min_v = it.annotation["min"].getWithDefault(0); + FAUSTFLOAT max_v = it.annotation["max"].getWithDefault(0); + FAUSTFLOAT init = it.annotation["init"].getWithDefault(0); + FAUSTFLOAT step = it.annotation["step"].getWithDefault(0); + ui_interface->addVerticalSlider(name.c_str(), &fZoneMap[i], init, min_v, max_v, step); + fZoneMap[i] = init; + fInputsFunMap[&fZoneMap[i]] = [=](FAUSTFLOAT value) { fPerformer.addInputEvent(fFactory->fHandleInputControls[name], 0, value); }; + i++; + } else if (choc::text::startsWith(name, "eventfEntry")) { + FAUSTFLOAT min_v = it.annotation["min"].getWithDefault(0); + FAUSTFLOAT max_v = it.annotation["max"].getWithDefault(0); + FAUSTFLOAT init = it.annotation["init"].getWithDefault(0); + FAUSTFLOAT step = it.annotation["step"].getWithDefault(0); + ui_interface->addNumEntry(name.c_str(), &fZoneMap[i], init, min_v, max_v, step); + fZoneMap[i] = init; + fInputsFunMap[&fZoneMap[i]] = [=](FAUSTFLOAT value) { fPerformer.addInputEvent(fFactory->fHandleInputControls[name], 0, value); }; + i++; + } + } + ui_interface->closeBox(); + // Outputs + ui_interface->openVerticalBox("Outputs"); + for (const auto& it : fEndpointOutputs) { + std::string name = it.endpointID.toString(); + uint32_t index = fFactory->fEngine.getEndpointHandle(name.c_str()); + if (choc::text::startsWith(name, "eventfHbargraph")) { + FAUSTFLOAT min_v = it.annotation["min"].getWithDefault(0); + FAUSTFLOAT max_v = it.annotation["max"].getWithDefault(0); + ui_interface->addHorizontalBargraph(name.c_str(), &fZoneMap[i], min_v, max_v); + fZoneMap[i] = 0; + fOutputsFunMap[&fZoneMap[i]] = [=]() { + FAUSTFLOAT value; fPerformer.copyOutputValue(fFactory->fHandleOutputControls[name], &value); return value; + }; + i++; + } else if (choc::text::startsWith(name, "eventfVbargraph")) { + FAUSTFLOAT min_v = it.annotation["min"].getWithDefault(0); + FAUSTFLOAT max_v = it.annotation["max"].getWithDefault(0); + ui_interface->addVerticalBargraph(name.c_str(), &fZoneMap[i], min_v, max_v); + fZoneMap[i] = 0; + fOutputsFunMap[&fZoneMap[i]] = [=]() { + FAUSTFLOAT value; fPerformer.copyOutputValue(fFactory->fHandleOutputControls[name], &value); return value; + }; + i++; + } + } + ui_interface->closeBox(); + ui_interface->closeBox(); +} + +void cmajorpatch_dsp::compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) +{ + fPerformer.setBlockSize(count); + + // Copy audio inputs + for (size_t chan = 0; chan < fFactory->fHandleInputs.size(); chan++) { + fPerformer.setInputFrames(fFactory->fHandleInputs[chan], inputs[chan], count); + } + + // Update input controls + updateInputControls(); + + // Render + fPerformer.advance(); + + // Copy audio outputs + for (size_t chan = 0; chan < fFactory->fHandleOutputs.size(); chan++) { + fPerformer.copyOutputFrames(fFactory->fHandleOutputs[chan], outputs[chan], count); + } + + // Update output controls + // updateOutputControls(); + + /* + // MIDI input handling + if (fMIDIHander) { + fRenderContext.numMIDIMessagesIn = fMIDIHander->recvMessages(reinterpret_cast*>(&fMIDIInputMessages)); + if (fRenderContext.numMIDIMessagesIn > 1024) { + std::cerr << "MIDI input overflow\n"; + } + fRenderContext.incomingMIDI = std::addressof(fMIDIInputMessages[0]); + fRenderContext.outgoingMIDI = std::addressof(fMIDIOutputMessages[0]); + fRenderContext.maximumMIDIMessagesOut = (uint32_t)fMIDIOutputMessages.size(); + fRenderContext.numMIDIMessagesOut = 0; + } else { + fRenderContext.incomingMIDI = nullptr; + fRenderContext.incomingMIDI = nullptr; + fRenderContext.numMIDIMessagesIn = 0; + } + */ + + /* + // MIDI output handling + if (fMIDIHander && fRenderContext.numMIDIMessagesOut != 0) { + if (fRenderContext.numMIDIMessagesOut > fRenderContext.maximumMIDIMessagesOut) { + std::cerr << "MIDI output overflow\n"; + } + int numMessagesOut = std::min(fRenderContext.numMIDIMessagesOut, fRenderContext.maximumMIDIMessagesOut); + fMIDIHander->sendMessages(reinterpret_cast*>(&fMIDIOutputMessages), numMessagesOut); + } + */ +} + +// External API + +cmajorpatch_dsp* cmajorpatch_dsp::clone() +{ + return fFactory->createDSPInstance(); +} + +cmajor_dsp_factory* getCmajorDSPFactoryFromSHAKey(const std::string& sha_key) +{ + return nullptr; +} + +cmajor_dsp_factory* createCmajorDSPFactoryFromString(const std::string& name_app, + const std::string& dsp_content, + int argc, const char* argv[], + std::string& error_msg) +{ + try { + return new cmajor_dsp_factory(dsp_content, error_msg); + } catch (...) { + if (error_msg == "") error_msg = "ERROR : createCmajorDSPFactoryFromString\n"; + return nullptr; + } +} + +cmajor_dsp_factory* createCmajorDSPFactoryFromFile(const std::string& filename, + int argc, const char* argv[], + std::string& error_msg) +{ + std::string base = basename((char*)filename.c_str()); + size_t pos = filename.find(".cmajor"); + + if (pos != std::string::npos) { + return createCmajorDSPFactoryFromString(base.substr(0, pos), pathToContent(filename), argc, argv, error_msg); + } else { + error_msg = "ERROR : file extension is not the one expected (.cmajor expected)\n"; + return nullptr; + } +} + +bool deleteCmajorDSPFactory(cmajor_dsp_factory* factory) +{ + delete factory; + return true; +} + +#endif +/************************** END cmajorpatch-dsp.h **************************/ diff -Nru faust-2.50.6+ds0/architecture/faust/dsp/dsp.h faust-2.54.9+ds0/architecture/faust/dsp/dsp.h --- faust-2.50.6+ds0/architecture/faust/dsp/dsp.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/dsp/dsp.h 2022-12-17 10:41:42.000000000 +0000 @@ -49,7 +49,7 @@ * 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) {} + virtual void begin(size_t /*count*/) {} /** * Give the Memory Manager information on a given memory zone. @@ -57,8 +57,8 @@ * @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) {} - + 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. @@ -225,6 +225,7 @@ virtual std::string getCompileOptions() = 0; virtual std::vector getLibraryList() = 0; virtual std::vector getIncludePathnames() = 0; + virtual std::vector getWarningMessages() = 0; virtual dsp* createDSPInstance() = 0; diff -Nru faust-2.50.6+ds0/architecture/faust/dsp/interpreter-dsp.h faust-2.54.9+ds0/architecture/faust/dsp/interpreter-dsp.h --- faust-2.50.6+ds0/architecture/faust/dsp/interpreter-dsp.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/dsp/interpreter-dsp.h 2022-12-17 10:41:42.000000000 +0000 @@ -122,6 +122,9 @@ /* Get the list of all used includes */ std::vector getIncludePathnames(); + /* Get warning messages list for a given compilation */ + std::vector getWarningMessages(); + /* Create a new DSP instance, to be deleted with C++ 'delete' */ interpreter_dsp* createDSPInstance(); diff -Nru faust-2.50.6+ds0/architecture/faust/dsp/interpreter-machine-dsp.h faust-2.54.9+ds0/architecture/faust/dsp/interpreter-machine-dsp.h --- faust-2.50.6+ds0/architecture/faust/dsp/interpreter-machine-dsp.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/dsp/interpreter-machine-dsp.h 2022-12-17 10:41:42.000000000 +0000 @@ -119,7 +119,10 @@ /* Get the list of all used includes */ std::vector getIncludePathnames(); - + + /* Get warning messages list for a given compilation */ + std::vector getWarningMessages(); + /* Create a new DSP instance, to be deleted with C++ 'delete' */ interpreter_dsp* createDSPInstance(); diff -Nru faust-2.50.6+ds0/architecture/faust/dsp/libfaust-box-c.h faust-2.54.9+ds0/architecture/faust/dsp/libfaust-box-c.h --- faust-2.50.6+ds0/architecture/faust/dsp/libfaust-box-c.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/dsp/libfaust-box-c.h 2022-12-17 10:41:42.000000000 +0000 @@ -699,11 +699,39 @@ */ LIBFAUST_API Signal* CboxesToSignals(Box box, char* error_msg); + /** + * Create source code in a target language from a box expression. + * + * @param name_app - the name of the Faust program + * @param box - the box expression + * @param lang - the target source code's language which can be one of "c", + * "cpp", "cmajor", "csharp", "dlang", "fir", "interp", "java", "julia", "ocpp", "rust" or "wast" + * (depending of which of the corresponding backends are compiled in libfaust) + * @param argc - the number of parameters in argv array + * @param argv - the array of parameters + * @param error_msg - the error string to be filled + * + * @return a string of source code on success (to be deleted by the caller using freeCMemory) or a nullptr and setting error_msg on error. + */ + LIBFAUST_API char* CcreateSourceFromBoxes(const char* name_app, Box box, + const char* lang, + int argc, const char* argv[], + char* error_msg); + + /** + * The free function to be used on memory returned CcreateSourceFromBoxes. + * + * This is MANDATORY on Windows when otherwise all nasty runtime version related crashes can occur. + * + * @param ptr - the pointer to be deleted. + */ + LIBFAUST_API void freeCMemory(void* ptr); + /* [1] Constant numerical expression : see https://faustdoc.grame.fr/manual/syntax/#constant-numerical-expressions [2] Label definition : https://faustdoc.grame.fr/manual/syntax/#variable-parts-of-a-label */ - + #ifdef __cplusplus } #endif diff -Nru faust-2.50.6+ds0/architecture/faust/dsp/libfaust-box.h faust-2.54.9+ds0/architecture/faust/dsp/libfaust-box.h --- faust-2.50.6+ds0/architecture/faust/dsp/libfaust-box.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/dsp/libfaust-box.h 2022-12-17 10:41:42.000000000 +0000 @@ -87,7 +87,7 @@ virtual ~dsp_factory_base() {} - virtual void write(std::ostream* out, bool binary = false, bool compact = false) {} + virtual void write(std::ostream* /*out*/, bool /*binary*/ = false, bool /*compact*/ = false) {} }; /** @@ -509,7 +509,6 @@ /** * Extended unary mathematical functions. */ - LIBFAUST_API Box boxAbs(); LIBFAUST_API Box boxAbs(Box x); LIBFAUST_API Box boxAcos(); @@ -544,7 +543,6 @@ /** * Extended binary mathematical functions. */ - LIBFAUST_API Box boxRemainder(); LIBFAUST_API Box boxRemainder(Box b1, Box b2); LIBFAUST_API Box boxPow(); @@ -730,7 +728,7 @@ * @param name_app - the name of the Faust program * @param box - the box expression * @param lang - the target source code's language which can be one of "c", - * "cpp", "csharp", "dlang", "fir", "java", "julia", "ocpp", "rust", "soul" or "wast" + * "cpp", "cmajor", "csharp", "dlang", "fir", "interp", "java", "julia", "ocpp", "rust" or "wast" * (depending of which of the corresponding backends are compiled in libfaust) * @param argc - the number of parameters in argv array * @param argv - the array of parameters diff -Nru faust-2.50.6+ds0/architecture/faust/dsp/libfaust-signal.h faust-2.54.9+ds0/architecture/faust/dsp/libfaust-signal.h --- faust-2.50.6+ds0/architecture/faust/dsp/libfaust-signal.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/dsp/libfaust-signal.h 2022-12-17 10:41:42.000000000 +0000 @@ -87,7 +87,7 @@ virtual ~dsp_factory_base() {} - virtual void write(std::ostream* out, bool binary = false, bool compact = false) {} + virtual void write(std::ostream* /*out*/, bool /*binary*/ = false, bool /*compact*/ = false) {} }; /** diff -Nru faust-2.50.6+ds0/architecture/faust/dsp/llvm-dsp-c.h faust-2.54.9+ds0/architecture/faust/dsp/llvm-dsp-c.h --- faust-2.50.6+ds0/architecture/faust/dsp/llvm-dsp-c.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/dsp/llvm-dsp-c.h 2022-12-17 10:41:42.000000000 +0000 @@ -252,6 +252,15 @@ LIBFAUST_API const char** getCDSPFactoryIncludePathnames(llvm_dsp_factory* factory); /** + * Get warning messages list for a given compilation as a null-terminated array. + * + * @param factory - the DSP factory. + * + * @return the warning messages list (the array and it's content has to be deleted by the caller using freeCMemory). + */ + LIBFAUST_API const char** getCWarningMessages(llvm_dsp_factory* factory); + + /** * Delete all Faust DSP factories kept in the library cache. Beware: all kept factory pointers (in local variables...) thus become invalid. */ LIBFAUST_API void deleteAllCDSPFactories(); diff -Nru faust-2.50.6+ds0/architecture/faust/dsp/llvm-dsp.h faust-2.54.9+ds0/architecture/faust/dsp/llvm-dsp.h --- faust-2.50.6+ds0/architecture/faust/dsp/llvm-dsp.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/dsp/llvm-dsp.h 2022-12-17 10:41:42.000000000 +0000 @@ -108,7 +108,7 @@ */ std::string getName(); - /* Return factory LLVM target (like 'i386-apple-macosx10.6.0:opteron')*/ + /* Return factory LLVM target (like 'i386-apple-macosx10.6.0:opteron') */ std::string getTarget(); /* Return factory SHA key */ @@ -125,6 +125,9 @@ /* Get the list of all used includes */ std::vector getIncludePathnames(); + + /* Get warning messages list for a given compilation */ + std::vector getWarningMessages(); /* Create a new DSP instance, to be deleted with C++ 'delete' */ llvm_dsp* createDSPInstance(); diff -Nru faust-2.50.6+ds0/architecture/faust/dsp/llvm-machine-dsp.h faust-2.54.9+ds0/architecture/faust/dsp/llvm-machine-dsp.h --- faust-2.50.6+ds0/architecture/faust/dsp/llvm-machine-dsp.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/dsp/llvm-machine-dsp.h 2022-12-17 10:41:42.000000000 +0000 @@ -118,6 +118,9 @@ /* Get the list of all used includes */ std::vector getIncludePathnames(); + /* Get warning messages list for a given compilation */ + std::vector getWarningMessages(); + /* Create a new DSP instance, to be deleted with C++ 'delete' */ llvm_dsp* createDSPInstance(); diff -Nru faust-2.50.6+ds0/architecture/faust/dsp/poly-dsp.h faust-2.54.9+ds0/architecture/faust/dsp/poly-dsp.h --- faust-2.50.6+ds0/architecture/faust/dsp/poly-dsp.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/dsp/poly-dsp.h 2022-12-17 10:41:42.000000000 +0000 @@ -996,13 +996,14 @@ virtual ~dsp_poly_factory() {} - virtual std::string getName() { return fProcessFactory->getName(); } - virtual std::string getSHAKey() { return fProcessFactory->getSHAKey(); } - virtual std::string getDSPCode() { return fProcessFactory->getDSPCode(); } - virtual std::string getCompileOptions() { return fProcessFactory->getCompileOptions(); } - virtual std::vector getLibraryList() { return fProcessFactory->getLibraryList(); } - virtual std::vector getIncludePathnames() { return fProcessFactory->getIncludePathnames(); } - + std::string getName() { return fProcessFactory->getName(); } + std::string getSHAKey() { return fProcessFactory->getSHAKey(); } + std::string getDSPCode() { return fProcessFactory->getDSPCode(); } + std::string getCompileOptions() { return fProcessFactory->getCompileOptions(); } + std::vector getLibraryList() { return fProcessFactory->getLibraryList(); } + std::vector getIncludePathnames() { return fProcessFactory->getIncludePathnames(); } + std::vector getWarningMessages() { return fProcessFactory->getWarningMessages(); } + std::string getEffectCode(const std::string& dsp_content) { std::stringstream effect_code; diff -Nru faust-2.50.6+ds0/architecture/faust/dsp/soul-cpp-dsp.h faust-2.54.9+ds0/architecture/faust/dsp/soul-cpp-dsp.h --- faust-2.50.6+ds0/architecture/faust/dsp/soul-cpp-dsp.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/dsp/soul-cpp-dsp.h 1970-01-01 00:00:00.000000000 +0000 @@ -1,215 +0,0 @@ -/************************** BEGIN soul-cpp-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 __soul_cpp_dsp__ -#define __soul_cpp_dsp__ - -#include -#include -#include -#include -#include -#include - -#include "faust/dsp/dsp.h" -#include "faust/gui/UI.h" -#include "faust/gui/JSONUIDecoder.h" - -// Generated with 'soul generate --cpp foo.soul --output=souldsp.h' -#include "souldsp.h" - -/** -* Faust wrapped C++ SOUL DSP -*/ - -class soul_cpp_dsp : public dsp { - - private: - - JSONUIDecoderBase* fDecoder; - souldsp fDSP; - - FAUSTFLOAT* fZoneMap; - std::map > fZoneFunMap; - - std::string unquote(const std::string& str) - { - return (str[0] == '"') ? str.substr(1, str.size() - 2) : str; - } - - bool startWith(const std::string& str, const std::string& prefix) - { - return (str.substr(0, prefix.size()) == prefix); - } - - void updateControls() - { - for (const auto& it : fZoneFunMap) { - it.second(*it.first); - } - } - - public: - - soul_cpp_dsp() - { - fDecoder = nullptr; - souldsp::ParameterList parameters = fDSP.createParameterList(); - fZoneMap = new FAUSTFLOAT[parameters.size()]; - } - - virtual ~soul_cpp_dsp() - { - delete fDecoder; - delete [] fZoneMap; - } - - virtual int getNumInputs() - { - return fDSP.numAudioInputChannels; - } - - virtual int getNumOutputs() - { - return fDSP.numAudioOutputChannels; - } - - virtual void buildUserInterface(UI* ui_interface) - { - //fDecoder->buildUserInterface(ui_interface); - - souldsp::ParameterList parameters = fDSP.createParameterList(); - for (int i = 0; i < parameters.size(); i++) { - souldsp::Parameter& param = parameters[i]; - souldsp::ParameterProperties& prop = param.properties; - if (prop.isBoolean) { - if (startWith(prop.UID, "eventfCheckbox")) { - ui_interface->addCheckButton(prop.name, &fZoneMap[i]); - } else if (startWith(prop.UID, "eventfButton")) { - ui_interface->addButton(prop.name, &fZoneMap[i]); - } - fZoneMap[i] = 0; - fZoneFunMap[&fZoneMap[i]] = param.applyValue; - } else if (startWith(prop.UID, "eventfHslider")) { - ui_interface->addHorizontalSlider(prop.name, &fZoneMap[i], prop.initialValue, prop.minValue, prop.maxValue, prop.step); - fZoneMap[i] = prop.initialValue; - fZoneFunMap[&fZoneMap[i]] = param.applyValue; - } else if (startWith(prop.UID, "eventfVslider")) { - ui_interface->addVerticalSlider(prop.name, &fZoneMap[i], prop.initialValue, prop.minValue, prop.maxValue, prop.step); - fZoneMap[i] = prop.initialValue; - fZoneFunMap[&fZoneMap[i]] = param.applyValue; - } else if (startWith(prop.UID, "eventfEntry")) { - ui_interface->addNumEntry(prop.name, &fZoneMap[i], prop.initialValue, prop.minValue, prop.maxValue, prop.step); - fZoneMap[i] = prop.initialValue; - fZoneFunMap[&fZoneMap[i]] = param.applyValue; - } else if (startWith(prop.UID, "eventfVbargraph")) { - ui_interface->addHorizontalBargraph(prop.name, &fZoneMap[i], prop.minValue, prop.maxValue); - fZoneMap[i] = 0; - } else if (startWith(prop.UID, "eventfHbargraph")) { - ui_interface->addVerticalBargraph(prop.name, &fZoneMap[i], prop.minValue, prop.maxValue); - fZoneMap[i] = 0; - } - } - } - - virtual int getSampleRate() - { - return fDSP.sampleRate; - } - - virtual void init(int sample_rate) - { - fDSP.init(double(sample_rate), 0); - } - - virtual void instanceInit(int sample_rate) - { - fDSP.sampleRate = double(sample_rate); - // classInit has to be called for each instance since the tables are actually not shared between instances - fDSP.addInputEvent_eventclassInit(sample_rate); - instanceConstants(sample_rate); - instanceResetUserInterface(); - instanceClear(); - } - - virtual void instanceConstants(int sample_rate) - { - fDSP.sampleRate = double(sample_rate); - fDSP.addInputEvent_eventinstanceConstants(sample_rate); - } - - virtual void instanceResetUserInterface() - { - fDSP.addInputEvent_eventinstanceResetUserInterface(0); - } - - virtual void instanceClear() - { - fDSP.addInputEvent_eventinstanceClear(0); - } - - virtual soul_cpp_dsp* clone() - { - return new soul_cpp_dsp(); - } - - virtual void metadata(Meta* m) - { - //fDecoder->metadata(m); - } - - void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) - { - // Prepare buffers - souldsp::RenderContext context; - if (souldsp::numAudioInputChannels > 0) { - for (int chan = 0; chan < souldsp::numAudioInputChannels; chan++) { - context.inputChannels[chan] = inputs[chan]; - } - } - - if (souldsp::numAudioOutputChannels > 0) { - for (int chan = 0; chan < souldsp::numAudioOutputChannels; chan++) { - context.outputChannels[chan] = outputs[chan]; - } - } - - // Update control - updateControls(); - - // Render - context.numFrames = count; - fDSP.render(context); - } - - virtual void compute(double /*date_usec*/, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) - { - compute(count, inputs, outputs); - } - -}; - -#endif - -/************************** END soul-cpp-dsp.h **************************/ diff -Nru faust-2.50.6+ds0/architecture/faust/dsp/soulpatch-dsp.h faust-2.54.9+ds0/architecture/faust/dsp/soulpatch-dsp.h --- faust-2.50.6+ds0/architecture/faust/dsp/soulpatch-dsp.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/dsp/soulpatch-dsp.h 1970-01-01 00:00:00.000000000 +0000 @@ -1,703 +0,0 @@ -/************************** BEGIN soulpatch-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 __soulpatch_dsp__ -#define __soulpatch_dsp__ - -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -#include "faust/dsp/dsp.h" -#include "faust/midi/midi.h" -#include "faust/gui/UI.h" -#include "faust/gui/JSONUIDecoder.h" -#include "faust/dsp/libfaust.h" - -class soul_dsp_factory; - -/** -* Faust wrapped SOUL DSP -*/ - -class soulpatch_dsp : public dsp { - - private: - - /* - struct ConsolePrinter : public soul::patch::RefCountHelper - { - // Called when a message is sent to the console by the program. - void handleConsoleMessage(uint64_t sampleCount, const char* endpointName, const char* message) - { - std::cout << sampleCount << " " << endpointName << ": " << message << std::endl; - } - }; - */ - - bool startWith(const std::string& str, const std::string& prefix) - { - return (str.substr(0, prefix.size()) == prefix); - } - - std::string unquote(const std::string& str) - { - return (str[0] == '"') ? str.substr(1, str.size() - 2) : str; - } - - int countTotalBusChannels(soul::patch::Span buses) - { - int res = 0; - for (const auto& i : buses) { - res += i.numChannels; - } - return res; - } - - bool checkParam(soul::patch::Span names, const std::string& name) - { - for (int i = 0; i < names.size(); i++) { - if (names[i] == name) return true; - } - return false; - } - - struct ZoneParam { - - FAUSTFLOAT fZone; - soul::patch::Parameter::Ptr fParam; - - ZoneParam(soul::patch::Parameter::Ptr param):fParam(param) - {} - - void reflectZone() { fParam->setValue(fZone); } - void modifyZone() { fZone = fParam->getValue(); } - - }; - - soul_dsp_factory* fFactory; - - std::vector fInputsControl; - std::vector fOutputsControl; - - soul::patch::PatchPlayer* fPlayer; - soul::patch::PatchPlayerConfiguration fConfig; - soul::patch::PatchPlayer::RenderContext fRenderContext; - - // Event handlers used to call additional functions - soul::patch::Parameter::Ptr fClassInit; - soul::patch::Parameter::Ptr fInstanceConstants; - soul::patch::Parameter::Ptr fInstanceResetUserInterface; - soul::patch::Parameter::Ptr fInstanceClear; - JSONUIDecoderBase* fDecoder; - - // MIDI handling - midi_handler* fMIDIHander; - std::vector fMIDIInputMessages; - std::vector fMIDIOutputMessages; - - public: - - // Implemented later on - soulpatch_dsp(soul_dsp_factory* factory, std::string& error_msg); - - virtual ~soulpatch_dsp() - { - for (const auto& i : fInputsControl) { - delete i; - } - for (const auto& i : fOutputsControl) { - delete i; - } - delete fDecoder; - } - - void setMidiHandler(midi_handler* handler) { fMIDIHander = handler; } - midi_handler* getMidiHandler() { return fMIDIHander; } - - virtual int getNumInputs() - { - return fRenderContext.numInputChannels; - } - - virtual int getNumOutputs() - { - return fRenderContext.numOutputChannels; - } - - virtual void buildUserInterface(UI* ui_interface) - { - if (fDecoder) { - - soul::patch::Span params = fPlayer->getParameters(); - for (int i = 0; i < params.size(); i++) { - std::string label = params[i]->ID->getCharPointer(); - if (label.find("Hslider") != std::string::npos - || label.find("Vslider") != std::string::npos - || label.find("Entry") != std::string::npos - || label.find("Button") != std::string::npos - || label.find("Checkbox") != std::string::npos) { - // Additional event handlers are added before the control handlers, so the control index start at 5 - fDecoder->setReflectZoneFun(i-5, [=](double value) { params[i]->setValue(value); }); - } else if (label.find("Hbargraph") != std::string::npos - || label.find("Vbargraph") != std::string::npos) { - // Additional event handlers are added before the control handlers, so the control index start at 5 - fDecoder->setModifyZoneFun(i-5, [=]() { std::cout << params[i]->getValue() << std::endl; return params[i]->getValue(); }); - } - } - fDecoder->buildUserInterface(ui_interface); - - } else { - - ui_interface->openVerticalBox("SOUL"); - { - ui_interface->openVerticalBox("Inputs"); - - soul::patch::Span params = fPlayer->getParameters(); - for (int i = 0; i < params.size(); i++) { - - std::string label = params[i]->ID->getCharPointer(); - ZoneParam* param = new ZoneParam(params[i]); - FAUSTFLOAT* zone = ¶m->fZone; - fInputsControl.push_back(param); - - // Possibly add 'Faust compatible' metadata - soul::patch::Span names = params[i]->getPropertyNames(); - for (int j = 0; j < names.size(); j++) { - std::string key = names[j]; - if (key == "unit") { - ui_interface->declare(zone, key.c_str(), params[i]->getProperty(names[j])->getCharPointer()); - } - } - - if (checkParam(params[i]->getPropertyNames(), "boolean")) { - ui_interface->addButton(params[i]->name->getCharPointer(), zone); - } else if (!checkParam(params[i]->getPropertyNames(), "hidden")) { - ui_interface->addHorizontalSlider(params[i]->name->getCharPointer(), zone, - params[i]->initialValue, params[i]->minValue, - params[i]->maxValue, params[i]->step); - } - } - - ui_interface->closeBox(); - } - { - ui_interface->openVerticalBox("Outputs"); - /* - soul::patch::Span params = fPlayer->getParameters(); - for (int i = 0; i < params.size(); i++) { - - std::string label = params[i]->ID->getCharPointer(); - ZoneParam* param = new ZoneParam(params[i]); - FAUSTFLOAT* zone = ¶m->fZone; - fOutputsControl.push_back(param); - - // Possibly add 'Faust compatible' metadata - soul::patch::Span names = params[i]->getPropertyNames(); - for (int j = 0; j < names.size(); j++) { - std::string key = names[j]; - if (key == "unit") { - ui_interface->declare(zone, key.c_str(), params[i]->getProperty(names[j])->getCharPointer()); - } - } - if (!(checkParam(params[i]->getPropertyNames(), "hidden"))) { - ui_interface->addVerticalBargraph(params[i]->name->getCharPointer(), zone, params[i]->minValue, params[i]->maxValue); - } - } - */ - ui_interface->closeBox(); - } - ui_interface->closeBox(); - } - } - - virtual int getSampleRate() - { - return int(fConfig.sampleRate); - } - - void classInit(int sample_rate) - { - if (fClassInit) fClassInit->setValue(0); - } - - // Implemented later on - virtual void init(int sample_rate); - - virtual void instanceInit(int sample_rate) - { - instanceConstants(sample_rate); - instanceResetUserInterface(); - instanceClear(); - } - - virtual void instanceConstants(int sample_rate) - { - if (fInstanceConstants) fInstanceConstants->setValue(0); - } - - virtual void instanceResetUserInterface() - { - if (fInstanceResetUserInterface) fInstanceResetUserInterface->setValue(0); - } - - virtual void instanceClear() - { - if (fInstanceClear) fInstanceClear->setValue(0); - } - - // Implemented later on - virtual soulpatch_dsp* clone(); - - virtual void metadata(Meta* m) {} - - virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) - { - // Update inputs control - if (fDecoder) { - for (const auto& i : fDecoder->getInputControls()) { - i->reflectZone(); - } - } else { - for (const auto& i : fInputsControl) { - i->reflectZone(); - } - } - - // MIDI input handling - if (fMIDIHander) { - fRenderContext.numMIDIMessagesIn = fMIDIHander->recvMessages(reinterpret_cast*>(&fMIDIInputMessages)); - if (fRenderContext.numMIDIMessagesIn > 1024) { - std::cerr << "MIDI input overflow\n"; - } - fRenderContext.incomingMIDI = std::addressof(fMIDIInputMessages[0]); - fRenderContext.outgoingMIDI = std::addressof(fMIDIOutputMessages[0]); - fRenderContext.maximumMIDIMessagesOut = (uint32_t)fMIDIOutputMessages.size(); - fRenderContext.numMIDIMessagesOut = 0; - } else { - fRenderContext.incomingMIDI = nullptr; - fRenderContext.incomingMIDI = nullptr; - fRenderContext.numMIDIMessagesIn = 0; - } - - // Setup audio buffers - fRenderContext.inputChannels = (const FAUSTFLOAT**)inputs; - fRenderContext.outputChannels = outputs; - fRenderContext.numFrames = count; - - // DSP compute - fPlayer->render(fRenderContext); - - // MIDI output handling - if (fMIDIHander && fRenderContext.numMIDIMessagesOut != 0) { - if (fRenderContext.numMIDIMessagesOut > fRenderContext.maximumMIDIMessagesOut) { - std::cerr << "MIDI output overflow\n"; - } - int numMessagesOut = std::min(fRenderContext.numMIDIMessagesOut, fRenderContext.maximumMIDIMessagesOut); - fMIDIHander->sendMessages(reinterpret_cast*>(&fMIDIOutputMessages), numMessagesOut); - } - - // Update outputs control - if (fDecoder) { - for (const auto& i : fDecoder->getOutputControls()) { - i->modifyZone(); - } - } else { - for (const auto& i : fOutputsControl) { - i->modifyZone(); - } - } - } - - virtual void compute(double /*date_usec*/, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { compute(count, inputs, outputs); } - -}; - -/** - * Faust wrapped SOUL patches factory - */ - -class soul_dsp_factory : public dsp_factory { - - protected: - - friend soulpatch_dsp; - - struct FaustSOULFile : public soul::patch::VirtualFile { - - virtual soul::patch::String* getName() { return {}; } - - virtual soul::patch::String* getAbsolutePath() { return {}; } - - virtual soul::patch::VirtualFile* getParent() { return {}; } - - virtual soul::patch::VirtualFile* getChildFile (const char* subPath) { return {}; } - - virtual int64_t getSize() { return 0; } - - virtual int64_t getLastModificationTime() { return 0; } - - virtual int64_t read (uint64_t startPositionInFile, void* targetBuffer, uint64_t bytesToRead) { return 0; } - - }; - - struct FaustSourceFilePreprocessor : public soul::patch::SourceFilePreprocessor { - - virtual soul::patch::VirtualFile* preprocessSourceFile (soul::patch::VirtualFile& inputFile) override - { - return {}; - } - - }; - - std::string fPath; - soul::patch::PatchInstance::Ptr fPatch; - soul::patch::Description* fDescription; - FaustSourceFilePreprocessor::Ptr fProcessor; - - public: - - soul_dsp_factory(const std::string& path, std::string& error_msg) - { - fPath = path; - std::string filename = "/usr/local/lib/" + std::string(soul::patch::SOULPatchLibrary::getLibraryFileName()); - soul::patch::SOULPatchLibrary library(filename.c_str()); - - if (!library.loadedSuccessfully()) { - error_msg = "cannot load SOUL_PatchLoader.dylib\n"; - throw std::bad_alloc(); - } - - fPatch = library.createPatchFromFileBundle(fPath.c_str()); - if (!fPatch) { - error_msg = "cannot load SOUL patch : " + path + "\n"; - throw std::bad_alloc(); - } - - fDescription = fPatch->getDescription(); - /* - std::cout << "name \"" << fDescription.name->getCharPointer() << "\"" << std::endl; - std::cout << "description \"" << fDescription.description->getCharPointer() << "\"" << std::endl; - std::cout << "category \"" << fDescription.category->getCharPointer() << "\"" << std::endl; - std::cout << "manufacturer \"" << fDescription.manufacturer->getCharPointer() << "\"" << std::endl; - std::cout << "URL \"" << fDescription.URL->getCharPointer() << "\"" << std::endl; - std::cout << "isInstrument " << fDescription.isInstrument << "\"" << std::endl; - */ - } - - virtual ~soul_dsp_factory() {} - - virtual std::string getName() { return fDescription->name; } - virtual std::string getSHAKey() { return ""; } - virtual std::string getDSPCode() { return ""; } - virtual std::string getCompileOptions() { return ""; } - virtual std::vector getLibraryList() { return {}; } - virtual std::vector getIncludePathnames() { return {}; } - - virtual soulpatch_dsp* createDSPInstance() - { - std::string error_msg; - return new soulpatch_dsp(this, error_msg); - } - - virtual void setMemoryManager(dsp_memory_manager* manager) {} - virtual dsp_memory_manager* getMemoryManager() { return nullptr; }; - -}; - -soulpatch_dsp::soulpatch_dsp(soul_dsp_factory* factory, std::string& error_msg) -{ - fFactory = factory; - fDecoder = nullptr; - fMIDIHander = nullptr; - memset(&fRenderContext, 0, sizeof(fRenderContext)); - - fConfig.sampleRate = 44100; - fConfig.maxFramesPerBlock = 4096; - fPlayer = fFactory->fPatch->compileNewPlayer(fConfig, nullptr, fFactory->fProcessor.get(), nullptr); - if (!fPlayer->isPlayable()) { - soul::patch::Span errors = fPlayer->getCompileMessages(); - error_msg = "getCompileError"; - for (int i = 0; i < errors.size(); i++) { - error_msg += " "; - error_msg += errors[i].getFullMessage(); - } - error_msg += "\n"; - throw std::bad_alloc(); - } - - // Setup fixed parts of the render context - fRenderContext.numInputChannels = countTotalBusChannels(fPlayer->getInputBuses()); - fRenderContext.numOutputChannels = countTotalBusChannels(fPlayer->getOutputBuses()); -} - -void soulpatch_dsp::init(int sample_rate) -{ - fConfig.sampleRate = double(sample_rate); - fPlayer = fFactory->fPatch->compileNewPlayer(fConfig, nullptr, fFactory->fProcessor.get(), nullptr); - fMIDIInputMessages.resize(1024); - fMIDIOutputMessages.resize(1024); - - // FAUST soul code has additional functions - soul::patch::Span params = fPlayer->getParameters(); - for (int i = 0; i < params.size(); i++) { - std::string label = params[i]->ID->getCharPointer(); - if (label == "eventbuildUserInterface") { - soul::patch::Span names = params[i]->getPropertyNames(); - // JSON is the first key - std::string json = unquote(params[i]->getProperty(names[0])->getCharPointer()); - json.erase(std::remove(json.begin(), json.end(), '\\'), json.end()); - fDecoder = createJSONUIDecoder(json); - } else if (label == "eventclassInit") { - fClassInit = params[i]; - } else if (label == "eventinstanceConstants") { - fInstanceConstants = params[i]; - } else if (label == "eventinstanceResetUserInterface") { - fInstanceResetUserInterface = params[i]; - } else if (label == "eventinstanceClear") { - fInstanceClear = params[i]; - } - } - - fPlayer->reset(); - classInit(sample_rate); - instanceInit(sample_rate); -} - -// External API - -soulpatch_dsp* soulpatch_dsp::clone() -{ - return fFactory->createDSPInstance(); -} - -soul_dsp_factory* getSOULDSPFactoryFromSHAKey(const std::string& sha_key) -{ - return nullptr; -} - -soul_dsp_factory* createSOULDSPFactoryFromFile(const std::string& filename, - int argc, const char* argv[], - std::string& error_msg) -{ - try { - soul_dsp_factory* factory = new soul_dsp_factory(filename, error_msg); - // Check that SOUL patch compilation works - soulpatch_dsp dummy(factory, error_msg); - return factory; - } catch (...) { - return nullptr; - } -} - -soul_dsp_factory* createSOULDSPFactoryFromString(const std::string& name_app, - const std::string& dsp_content, - int argc, const char* argv[], - std::string& error_msg) -{ - return nullptr; -} - -bool deleteSOULDSPFactory(soul_dsp_factory* factory) -{ - return false; -} - -/** - * Faust/SOUL hybrid file parser - */ - -class faust_soul_parser { - - private: - - std::map extractFaustBlocks(std::istream& in, std::stringstream& res_file) - { - std::string line; - std::stringstream faust_block; - bool is_faust_block = false; - int brackets = 0; - std::map faust_blocks; // name, code - std::map ::iterator cur_faust_block; - - while (getline(in, line)) { - - std::stringstream line_reader(line); - std::string token1, token2, token3; - - line_reader >> token1; - line_reader >> token2; - line_reader >> token3; - - if (is_faust_block) { - // End of block - if ((token1 == "}") && (--brackets == 0)) { - is_faust_block = false; - cur_faust_block->second = faust_block.str(); - faust_block.str(""); - // Start of block (or could be on the previous line) - } else if (token1 == "{") { - brackets++; - continue; - } else { - faust_block << line << "\n"; - } - continue; - } else { - is_faust_block = (token1 == "faust" && token2 != ""); - if (is_faust_block) { - if (token3 == "{") brackets++; - faust_blocks[token2] = ""; - cur_faust_block = faust_blocks.find(token2); - } - } - - // Keep the lines of SOUL file - if (!is_faust_block) res_file << line << std::endl; - } - - return faust_blocks; - } - - std::string generateSOULBlock(const std::string& name, const std::string& code, int argc, const char* argv[]) - { - int argc1 = 0; - const char* argv1[64]; - argv1[argc1++] = "-lang"; - //argv1[argc1++] = "soul"; - argv1[argc1++] = "soul-hybrid"; - argv1[argc1++] = "-cn"; - argv1[argc1++] = name.c_str(); - argv1[argc1++] = "-o"; - argv1[argc1++] = "/var/tmp/exp.soul"; - for (int i = 0; i < argc; i++) { - argv1[argc1++] = argv[i]; - } - argv1[argc1] = nullptr; // NULL terminated argv - - std::string error_msg; - bool res = generateAuxFilesFromString(name, code, argc1, argv1, error_msg); - - if (res) { - std::ifstream soul_file("/var/tmp/exp.soul"); - std::string soul_string((std::istreambuf_iterator(soul_file)), std::istreambuf_iterator()); - return soul_string; - } else { - std::cerr << "ERROR : generateAuxFilesFromFile " << error_msg; - return ""; - } - } - - public: - - faust_soul_parser() - {} - - ~faust_soul_parser() - {} - - bool parseSOULFile(const std::string& input, const std::string& output, int argc, const char* argv[]) - { - std::ifstream reader(input.c_str()); - if (reader.is_open()) { - - // Open SOUL output file - std::ofstream output_file(output); - - // Extract the Faust blocks and returns the input file without them - std::stringstream soul_file; - std::map faust_blocks = extractFaustBlocks(reader, soul_file); - - // Write all Faust blocks translated to SOUL - for (const auto& it : faust_blocks) { - std::string block = generateSOULBlock(it.first, it.second, argc, argv); - if (block == "") return false; - output_file << block; - } - - // Write the SOUL part - output_file << soul_file.str(); - output_file.close(); - - return true; - } else { - return false; - } - } - - bool generateSOULFile(const std::string& input, const std::string& output, int argc, const char* argv[]) - { - int argc1 = 0; - const char* argv1[64]; - argv1[argc1++] = "-lang"; - argv1[argc1++] = "soul"; - argv1[argc1++] = "-o"; - argv1[argc1++] = output.c_str(); - for (int i = 0; i < argc; i++) { - argv1[argc1++] = argv[i]; - } - argv1[argc1] = nullptr; // NULL terminated argv - - std::string error_msg; - bool res = generateAuxFilesFromFile(input, argc1, argv1, error_msg); - if (!res) { - std::cerr << "ERROR : generateAuxFilesFromFile " << error_msg; - } - return res; - } - - void createSOULPatch(const std::string& soul_file) - { - // Generate "soulpatch" file - std::string soulpatch_file = soul_file + "patch"; - std::ofstream patch_file(soulpatch_file); - patch_file << "{" << std::endl; - patch_file << "\t\"soulPatchV1\":" << std::endl; - patch_file << "\t{" << std::endl; - patch_file << "\t\t\"ID\": \"grame.soul.hybrid\"," << std::endl; - patch_file << "\t\t\"version\": \"1.0\"," << std::endl; - patch_file << "\t\t\"name\": \"hybrid\"," << std::endl; - patch_file << "\t\t\"description\": \"SOUL example\"," << std::endl; - patch_file << "\t\t\"category\": \"synth\"," << std::endl; - patch_file << "\t\t\"manufacturer\": \"GRAME\"," << std::endl; - patch_file << "\t\t\"website\": \"https://faust.grame.fr\"," << std::endl; - patch_file << "\t\t\"isInstrument\": true," << std::endl; - patch_file << "\t\t\"source\": "; patch_file << "\"" << soul_file << "\"" << std::endl; - patch_file << "\t}" << std::endl; - patch_file << "}"; - patch_file.close(); - } - -}; - -#endif -/************************** END soulpatch-dsp.h **************************/ diff -Nru faust-2.50.6+ds0/architecture/faust/dsp/wasm-dsp.h faust-2.54.9+ds0/architecture/faust/dsp/wasm-dsp.h --- faust-2.50.6+ds0/architecture/faust/dsp/wasm-dsp.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/dsp/wasm-dsp.h 2022-12-17 10:41:42.000000000 +0000 @@ -113,7 +113,10 @@ /* Get the list of all used includes */ std::vector getIncludePathnames(); - + + /* Get warning messages list for a given compilation */ + std::vector getWarningMessages(); + /* Create a new DSP instance, to be deleted with C++ 'delete' */ wasm_dsp* createDSPInstance(); diff -Nru faust-2.50.6+ds0/architecture/faust/export.h faust-2.54.9+ds0/architecture/faust/export.h --- faust-2.50.6+ds0/architecture/faust/export.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/export.h 2022-12-17 10:41:42.000000000 +0000 @@ -1,28 +1,31 @@ /************************************************************************ - ************************************************************************ - FAUST compiler - Copyright (C) 2003-2018 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 General Public License as published by - the Free Software Foundation; either version 2 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, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - ************************************************************************ - ************************************************************************/ + 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__ -#define FAUSTVERSION "2.50.6" +#define FAUSTVERSION "2.54.9" // 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 diff -Nru faust-2.50.6+ds0/architecture/faust/gui/console.h faust-2.54.9+ds0/architecture/faust/gui/console.h --- faust-2.50.6+ds0/architecture/faust/gui/console.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/gui/console.h 2022-12-17 10:41:42.000000000 +0000 @@ -34,6 +34,8 @@ #include #include #include +#include +#include #include #include "faust/gui/GUI.h" @@ -54,6 +56,9 @@ { private: + std::atomic fRun; + std::thread* fThread; + struct param { FAUSTFLOAT* fZone; FAUSTFLOAT fMin; FAUSTFLOAT fMax; param(FAUSTFLOAT* z, FAUSTFLOAT init, FAUSTFLOAT a, FAUSTFLOAT b) : fZone(z), fMin(a), fMax(b) { *z = init; } @@ -135,8 +140,14 @@ public: CMDUI(int argc, char* argv[], bool ignore_param = false) - : UI(), fArgc(argc), fArgv(argv), fIgnoreParam(ignore_param) { fPrefix.push("-"); } - virtual ~CMDUI() {} + : UI(), fThread(nullptr), fRun(true), + fArgc(argc), fArgv(argv), + fIgnoreParam(ignore_param) + { + fPrefix.push("-"); + } + + virtual ~CMDUI() { delete fThread; } // Can be used as public method void addOption(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max) @@ -184,14 +195,24 @@ virtual void addSoundfile(const char* label, const char* filename, Soundfile** sf_zone) {} + static void update_gui(CMDUI* ui) + { + while (ui->fRun) { + usleep(40 * 1000); // 25Hz + GUI::updateAllGuis(); + } + } + virtual bool run() { - char c; + fThread = new std::thread(update_gui, this); std::cout << "Type 'q' to quit\n"; + char c; while ((c = getchar()) && (c != 'q')) { - usleep(40 * 1000); // 25Hz - GUI::updateAllGuis(); + usleep(100 * 1000); } + fRun = false; + fThread->join(); return true; } diff -Nru faust-2.50.6+ds0/architecture/faust/gui/JuceGUI.h faust-2.54.9+ds0/architecture/faust/gui/JuceGUI.h --- faust-2.50.6+ds0/architecture/faust/gui/JuceGUI.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/gui/JuceGUI.h 2022-12-17 10:41:42.000000000 +0000 @@ -1977,12 +1977,14 @@ /** Add an horizontal slider to the user interface. */ virtual void addHorizontalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) override { + if (isHidden(zone)) return; addSlider(label, zone, init, min, max, step, kHSliderWidth, kHSliderHeight, HSlider); } /** Add a vertical slider to the user interface. */ virtual void addVerticalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) override { + if (isHidden(zone)) return; int newWidth = juce::jmax(juce::Font().getStringWidth(juce::String(label)), kVSliderWidth) + kMargin; addSlider(label, zone, init, min, max, step, newWidth, kVSliderHeight, VSlider); } @@ -1990,12 +1992,14 @@ /** Add a button to the user interface. */ virtual void addButton(const char* label, FAUSTFLOAT* zone) override { + if (isHidden(zone)) return; fCurrentBox->add(new uiButton(this, zone, kButtonWidth, kButtonHeight, juce::String(label), juce::String(fTooltip[zone]))); } /** Add a check button to the user interface. */ virtual void addCheckButton(const char* label, FAUSTFLOAT* zone) override { + if (isHidden(zone)) return; // newWidth is his text size, plus the check box size int newWidth = juce::Font().getStringWidth(juce::String(label)) + kCheckButtonWidth; fCurrentBox->add(new uiCheckButton(this, zone, newWidth, kCheckButtonHeight, juce::String(label), juce::String(fTooltip[zone]))); @@ -2004,6 +2008,7 @@ /** Add a numerical entry to the user interface. */ virtual void addNumEntry(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) override { + if (isHidden(zone)) return; // kMargin pixels between the slider and his name int newWidth = juce::Font().getStringWidth(juce::String(label)) + kNumEntryWidth + kMargin; fCurrentBox->add(new uiSlider(this, zone, newWidth, kNumEntryHeight, *zone, min, max, step, juce::String(label), juce::String(fUnit[zone]), juce::String(fTooltip[zone]), getScale(zone), NumEntry)); @@ -2012,12 +2017,14 @@ /** Add a vertical bargraph to the user interface. */ virtual void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) override { + if (isHidden(zone)) return; addBargraph(label, zone, min, max, kVBargraphWidth, kVBargraphHeight, VVUMeter); } /** Add a vertical bargraph to the user interface. */ virtual void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) override { + if (isHidden(zone)) return; addBargraph(label, zone, min, max, kHBargraphWidth, kHBargraphHeight, HVUMeter); } diff -Nru faust-2.50.6+ds0/architecture/faust/gui/JuceReader.h faust-2.54.9+ds0/architecture/faust/gui/JuceReader.h --- faust-2.50.6+ds0/architecture/faust/gui/JuceReader.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/gui/JuceReader.h 2022-12-17 10:41:42.000000000 +0000 @@ -39,7 +39,7 @@ virtual ~JuceReader() {} - bool checkFile(const std::string& path_name) + bool checkFile(const std::string& path_name) override { juce::File file(path_name); if (file.existsAsFile()) { @@ -50,14 +50,14 @@ } } - void getParamsFile(const std::string& path_name, int& channels, int& length) + void getParamsFile(const std::string& path_name, int& channels, int& length) override { std::unique_ptr formatReader (fFormatManager.createReaderFor (juce::File (path_name))); channels = int(formatReader->numChannels); length = int(formatReader->lengthInSamples); } - void readFile(Soundfile* soundfile, const std::string& path_name, int part, int& offset, int max_chan) + void readFile(Soundfile* soundfile, const std::string& path_name, int part, int& offset, int max_chan) override { std::unique_ptr formatReader (fFormatManager.createReaderFor (juce::File (path_name))); diff -Nru faust-2.50.6+ds0/architecture/faust/gui/LibsndfileReader.h faust-2.54.9+ds0/architecture/faust/gui/LibsndfileReader.h --- faust-2.50.6+ds0/architecture/faust/gui/LibsndfileReader.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/gui/LibsndfileReader.h 2022-12-17 10:41:42.000000000 +0000 @@ -141,7 +141,7 @@ typedef sf_count_t (* sample_read)(SNDFILE* sndfile, void* buffer, sf_count_t frames); // Check file - bool checkFile(const std::string& path_name) + bool checkFile(const std::string& path_name) override { SF_INFO snd_info; snd_info.format = 0; @@ -149,7 +149,7 @@ return checkFileAux(snd_file, path_name); } - bool checkFile(unsigned char* buffer, size_t length) + bool checkFile(unsigned char* buffer, size_t length) override { SF_INFO snd_info; snd_info.format = 0; @@ -170,7 +170,7 @@ } // Open the file and returns its length and channels - void getParamsFile(const std::string& path_name, int& channels, int& length) + void getParamsFile(const std::string& path_name, int& channels, int& length) override { SF_INFO snd_info; snd_info.format = 0; @@ -178,7 +178,7 @@ getParamsFileAux(snd_file, snd_info, channels, length); } - void getParamsFile(unsigned char* buffer, size_t size, int& channels, int& length) + void getParamsFile(unsigned char* buffer, size_t size, int& channels, int& length) override { SF_INFO snd_info; snd_info.format = 0; @@ -200,7 +200,7 @@ } // Read the file - void readFile(Soundfile* soundfile, const std::string& path_name, int part, int& offset, int max_chan) + void readFile(Soundfile* soundfile, const std::string& path_name, int part, int& offset, int max_chan) override { SF_INFO snd_info; snd_info.format = 0; @@ -208,7 +208,7 @@ readFileAux(soundfile, snd_file, snd_info, part, offset, max_chan); } - void readFile(Soundfile* soundfile, unsigned char* buffer, size_t length, int part, int& offset, int max_chan) + void readFile(Soundfile* soundfile, unsigned char* buffer, size_t length, int part, int& offset, int max_chan) override { SF_INFO snd_info; snd_info.format = 0; diff -Nru faust-2.50.6+ds0/architecture/faust/gui/MemoryReader.h faust-2.54.9+ds0/architecture/faust/gui/MemoryReader.h --- faust-2.50.6+ds0/architecture/faust/gui/MemoryReader.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/gui/MemoryReader.h 2022-12-17 10:41:42.000000000 +0000 @@ -45,6 +45,8 @@ MemoryReader() {} + virtual ~MemoryReader() + {} /** * Check the availability of a sound resource. @@ -53,7 +55,7 @@ * * @return true if the sound resource is available, false otherwise. */ - virtual bool checkFile(const std::string& path_name) { return true; } + virtual bool checkFile(const std::string& path_name) override { return true; } /** * Get the channels and length values of the given sound resource. @@ -63,7 +65,7 @@ * @param length - the length value to be filled with the sound resource length in frames * */ - virtual void getParamsFile(const std::string& path_name, int& channels, int& length) + virtual void getParamsFile(const std::string& path_name, int& channels, int& length) override { channels = SOUND_CHAN; length = SOUND_LENGTH; @@ -78,7 +80,7 @@ * @param max_chan - the maximum number of mono channels to fill * */ - virtual void readFile(Soundfile* soundfile, const std::string& path_name, int part, int& offset, int max_chan) + virtual void readFile(Soundfile* soundfile, const std::string& path_name, int part, int& offset, int max_chan) override { soundfile->fLength[part] = SOUND_LENGTH; soundfile->fSR[part] = SOUND_SR; diff -Nru faust-2.50.6+ds0/architecture/faust/gui/MetaDataUI.h faust-2.54.9+ds0/architecture/faust/gui/MetaDataUI.h --- faust-2.50.6+ds0/architecture/faust/gui/MetaDataUI.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/gui/MetaDataUI.h 2022-12-17 10:41:42.000000000 +0000 @@ -309,7 +309,7 @@ if (strcmp(key, "tooltip") == 0) { // only group tooltip are currently implemented fGroupTooltip = formatTooltip(30, value); - } else if (strcmp(key, "hidden") == 0) { + } else if ((strcmp(key, "hidden") == 0) && (strcmp(value, "1") == 0)) { fHiddenSet.insert(zone); } } else { @@ -322,7 +322,7 @@ else if (strcmp(key, "unit") == 0) { fUnit[zone] = value; } - else if (strcmp(key, "hidden") == 0) { + else if ((strcmp(key, "hidden") == 0) && (strcmp(value, "1") == 0)) { fHiddenSet.insert(zone); } else if (strcmp(key, "scale") == 0) { diff -Nru faust-2.50.6+ds0/architecture/faust/gui/Soundfile.h faust-2.54.9+ds0/architecture/faust/gui/Soundfile.h --- faust-2.50.6+ds0/architecture/faust/gui/Soundfile.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/gui/Soundfile.h 2022-12-17 10:41:42.000000000 +0000 @@ -265,6 +265,7 @@ public: + SoundfileReader() {} virtual ~SoundfileReader() {} void setSampleRate(int sample_rate) { fDriverSR = sample_rate; } diff -Nru faust-2.50.6+ds0/architecture/faust/gui/SoundUI.h faust-2.54.9+ds0/architecture/faust/gui/SoundUI.h --- faust-2.50.6+ds0/architecture/faust/gui/SoundUI.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/gui/SoundUI.h 2022-12-17 10:41:42.000000000 +0000 @@ -29,6 +29,7 @@ #include #include #include +#include #include "faust/gui/SimpleParser.h" #include "faust/gui/DecoratorUI.h" @@ -66,9 +67,12 @@ protected: - std::vector fSoundfileDir; // The soundfile directories - std::map fSoundfileMap; // Map to share loaded soundfiles - SoundfileReader* fSoundReader; + // The soundfile directories + std::vector fSoundfileDir; + // Map to share loaded soundfiles + std::map> fSoundfileMap; + // The soundfile reader + std::shared_ptr fSoundReader; bool fIsDouble; public: @@ -86,7 +90,10 @@ SoundUI(const std::string& sound_directory = "", int sample_rate = -1, SoundfileReader* reader = nullptr, bool is_double = false) { fSoundfileDir.push_back(sound_directory); - fSoundReader = (reader) ? reader : &gReader; + fSoundReader = (reader) + ? std::shared_ptr(reader) + // the static gReader should not be deleted, so use an empty destructor + : std::shared_ptr(std::shared_ptr{}, &gReader); fSoundReader->setSampleRate(sample_rate); fIsDouble = is_double; if (!defaultsound) defaultsound = gReader.createSoundfile(path_name_list, MAX_CHAN, is_double); @@ -105,19 +112,17 @@ SoundUI(const std::vector& sound_directories, int sample_rate = -1, SoundfileReader* reader = nullptr, bool is_double = false) :fSoundfileDir(sound_directories) { - fSoundReader = (reader) ? reader : &gReader; + fSoundReader = (reader) + ? std::shared_ptr(reader) + // the static gReader should not be deleted, so use an empty destructor + : std::shared_ptr(std::shared_ptr{}, &gReader); fSoundReader->setSampleRate(sample_rate); fIsDouble = is_double; if (!defaultsound) defaultsound = gReader.createSoundfile(path_name_list, MAX_CHAN, is_double); } virtual ~SoundUI() - { - // Delete all soundfiles - for (const auto& it : fSoundfileMap) { - delete it.second; - } - } + {} // -- soundfiles virtual void addSoundfile(const char* label, const char* url, Soundfile** sf_zone) @@ -137,7 +142,7 @@ // Read them and create the Soundfile Soundfile* sound_file = fSoundReader->createSoundfile(path_name_list, MAX_CHAN, fIsDouble); if (sound_file) { - fSoundfileMap[saved_url_real] = sound_file; + fSoundfileMap[saved_url_real] = std::shared_ptr(sound_file); } else { // If failure, use 'defaultsound' std::cerr << "addSoundfile : soundfile for " << saved_url << " cannot be created !" << std::endl; @@ -146,8 +151,8 @@ } } - // Get the soundfile - *sf_zone = fSoundfileMap[saved_url_real]; + // Get the soundfile pointer + *sf_zone = fSoundfileMap[saved_url_real].get(); } /** diff -Nru faust-2.50.6+ds0/architecture/faust/gui/UI.h faust-2.54.9+ds0/architecture/faust/gui/UI.h --- faust-2.50.6+ds0/architecture/faust/gui/UI.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/gui/UI.h 2022-12-17 10:41:42.000000000 +0000 @@ -72,8 +72,8 @@ // -- metadata declarations - virtual void declare(REAL* zone, const char* key, const char* val) {} - + virtual void declare(REAL* /*zone*/, const char* /*key*/, const char* /*val*/) {} + // To be used by LLVM client virtual int sizeOfFAUSTFLOAT() { return sizeof(FAUSTFLOAT); } }; diff -Nru faust-2.50.6+ds0/architecture/faust/gui/WaveReader.h faust-2.54.9+ds0/architecture/faust/gui/WaveReader.h --- faust-2.50.6+ds0/architecture/faust/gui/WaveReader.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/faust/gui/WaveReader.h 2022-12-17 10:41:42.000000000 +0000 @@ -310,7 +310,7 @@ WaveReader() {} virtual ~WaveReader() {} - virtual bool checkFile(const std::string& path_name) + bool checkFile(const std::string& path_name) override { try { FileReader reader(path_name); @@ -320,14 +320,14 @@ } } - virtual void getParamsFile(const std::string& path_name, int& channels, int& length) + void getParamsFile(const std::string& path_name, int& channels, int& length) override { FileReader reader(path_name); channels = reader.fWave->num_channels; length = (reader.fWave->subchunk_2_size * 8) / (reader.fWave->num_channels * reader.fWave->bits_per_sample); } - virtual void readFile(Soundfile* soundfile, const std::string& path_name, int part, int& offset, int max_chan) + void readFile(Soundfile* soundfile, const std::string& path_name, int part, int& offset, int max_chan) override { FileReader reader(path_name); reader.load_wave(); diff -Nru faust-2.50.6+ds0/architecture/jack-console.cpp faust-2.54.9+ds0/architecture/jack-console.cpp --- faust-2.50.6+ds0/architecture/jack-console.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/jack-console.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -253,7 +253,7 @@ #endif interface.run(); - + #ifdef MIDICTRL midiinterface->stop(); #endif diff -Nru faust-2.50.6+ds0/architecture/jack.rs faust-2.54.9+ds0/architecture/jack.rs --- faust-2.50.6+ds0/architecture/jack.rs 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/jack.rs 2022-12-17 10:41:42.000000000 +0000 @@ -108,7 +108,17 @@ let (client, _status) = j::Client::new("faust_rust", j::client_options::NO_START_SERVER).unwrap(); // Allocation DSP on the heap - let mut dsp = Box::new(mydsp::new()); + let mut dsp; + #[cfg(feature = "default-boxed")] + { + use default_boxed::DefaultBoxed; + dsp = mydsp::default_boxed(); + } + + #[cfg(not(feature = "default-boxed"))] + { + dsp = Box::new(mydsp::new()); + } println!("Faust Rust code running with JACK: sample-rate = {} buffer-size = {}", client.sample_rate(), client.buffer_size()); diff -Nru faust-2.50.6+ds0/architecture/jax/minimal.py faust-2.54.9+ds0/architecture/jax/minimal.py --- faust-2.50.6+ds0/architecture/jax/minimal.py 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/architecture/jax/minimal.py 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,189 @@ +# ************************************************************************ +# FAUST Architecture File +# Copyright (C) 2022 GRAME, Centre National de Creation Musicale +# --------------------------------------------------------------------- + +# This is sample code. This file is provided as an example of minimal +# FAUST architecture file. Redistribution and use in source and binary +# forms, with or without modification, in part or in full are permitted. +# In particular you can create a derived work of this FAUST architecture +# and distribute that work under terms of your choice. + +# This sample code 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. +# ************************************************************************ + +import json +import re +from typing import List + +import numpy as np +import librosa +import jax +import jax.numpy as jnp +from jax import random +from flax import linen as nn + + +def remainder(x, y): + a = jnp.remainder(x, y) + return a - y*((a > y/2).astype(jnp.int32)) + + +# Generated code +<> +<> + + def load_soundfile(self, filepath): + try: + audio, sr = librosa.load(filepath, mono=False, sr=None) + except FileNotFoundError: + return np.zeros((1,1024)), 44100 + if audio.ndim == 1: + audio = np.expand_dims(audio, 0) + return audio, sr + + def add_soundfile(self, state, zone: str, ui_path: List[str], label: str, url: str, x): + # todo: better parsing + filepaths = url[2:-2].split("';'") + fLength, fOffset, fSR, offset = [], [], [], 0 + audio_data = [self.load_soundfile(filepath) for filepath in filepaths] + num_chans = max([y.shape[0] for y, _ in audio_data]) + total_length = sum([y.shape[1] for y, _ in audio_data]) + fBuffers = jnp.zeros((num_chans, total_length)) + for y, sr in audio_data: + fSR.append(sr) + assert y.ndim == 2 + y = jnp.array(y) + fLength.append(y.shape[1]) + fOffset.append(offset) + fBuffers = fBuffers.at[:y.shape[0],offset:offset+y.shape[1]].set(y) + offset += y.shape[1] + if label.startswith('param:'): + label = label[6:] # remove param: + label = "/".join(ui_path+[label]) + fBuffers = self.param("_"+label, (lambda key, shape: fBuffers), None) + else: + label = "/".join(ui_path+[label]) + self.sow('intermediates', label, fBuffers) + state[zone] = {'fLength': fLength, 'fOffset': fOffset, 'fBuffers': fBuffers, 'fSR': fSR} + + def add_button(self, state, zone: str, ui_path: List[str], label: str): + label = "/".join(ui_path+[label]) + param = self.param("_"+label, nn.initializers.constant(0.), ()) + param = jnp.where(param>0., 1., 0.) + self.sow('intermediates', label, param) + state[zone] = param + + def add_nentry(self, state, zone: str, ui_path: List[str], label: str, init: float, a_min: float, a_max: float, step_size: float, scale_mode='linear'): + label = "/".join(ui_path+[label]) + num_steps = int(round((a_max-a_min)/step_size))+1 + init_unit = int(round(init-a_min)/step_size) + param = jnp.ones((num_steps,)) + param = param.at[init_unit].set(2) + param = nn.softmax(param) + param = self.param("_"+label, (lambda key, shape: param), None) + param = jnp.argmax(param, axis=-1)*step_size+a_min + self.sow('intermediates', label, param) + state[zone] = param + + def add_slider(self, state, zone: str, ui_path: List[str], label: str, init: float, a_min: float, a_max: float, scale_mode='linear'): + label = "/".join(ui_path+[label]) + init, a_min, a_max = float(init), float(a_min), float(a_max) + if scale_mode == 'linear': + init = jnp.interp(init, jnp.array([a_min, a_max]), jnp.array([-1.,1.])) + param = self.param("_"+label, nn.initializers.constant(init), ()) + param = jnp.clip(param, -1., 1.) + param = jnp.interp(param, jnp.array([-1., 1.]), jnp.array([a_min, a_max])) + elif scale_mode == 'exp': + init = jnp.interp(init, jnp.array([a_min, a_max]), jnp.array([1., jnp.e])) + init = jnp.log(init) + init = jnp.interp(init, jnp.array([0., 1.]), jnp.array([-1.,1.])) + param = self.param("_"+label, nn.initializers.constant(init), ()) + param = jnp.clip(param, -1., 1.) + param = jnp.interp(param, jnp.array([-1., 1.]), jnp.array([0., 1.])) + param = jnp.interp(jnp.exp(param), jnp.array([1., jnp.e]), jnp.array([a_min, a_max])) + elif scale_mode == 'log': + init = jnp.interp(init, jnp.array([a_min, a_max]), jnp.array([-4., 0.])) + init = jnp.power(10., init) + init = jnp.interp(init, jnp.array([10.**-4., 1.]), jnp.array([-1.,1.])) + param = self.param("_"+label, nn.initializers.constant(init), ()) + param = jnp.clip(param, -1., 1.) + param = jnp.interp(param, jnp.array([-1., 1.]), jnp.array([10.**-4., 1.])) + param = jnp.interp(jnp.log10(param), jnp.array([-4., 0.]), jnp.array([a_min, a_max])) + else: + raise ValueError(f"Unknown scale '{scale_mode}'.") + self.sow('intermediates', label, param) + state[zone] = param + + @nn.compact + def __call__(self, x, T: int) -> jnp.array: + state = self.initialize(self.sample_rate, x, T) + state = self.build_interface(state, x, T) + # convert numpy array to jax numpy array + state = jax.tree_map(jnp.array, state) + return jnp.transpose(jax.lax.scan(self.tick, state, jnp.transpose(x, axes=(1, 0)))[1], axes=(1,0)) + + +def test(args): + + model = mydsp(sample_rate=args.sample_rate) + print("NUM INPUT CHANNELS: ", model.getNumInputs()) + print("NUM OUTPUT CHANNELS: ", model.getNumOutputs()) + + json_obj = model.getJSON() + # print('json_obj: ', json_obj) + + key = random.PRNGKey(0) + + if args.input is not None: + input_audio, _ = librosa.load(args.input, mono=False, sr=args.sample_rate, duration=args.duration) + if input_audio.ndim == 1: + input_audio = input_audio.unsqueeze(0) + + N_SAMPLES = input_audio.shape[1] + N_CHANNELS = input_audio.shape[0] + assert N_CHANNELS == model.getNumInputs() + + input_audio = FAUSTFLOAT(input_audio) + else: + duration_sec = args.duration or 1. # default to 1 second when making noise. + + N_SAMPLES = int(duration_sec*args.sample_rate) + N_CHANNELS = model.getNumInputs() + + if args.random: + input_audio = -1.+2.*random.uniform(key, shape=(N_CHANNELS, N_SAMPLES), dtype=FAUSTFLOAT) + else: + input_audio = jnp.zeros((N_CHANNELS, N_SAMPLES), dtype=FAUSTFLOAT) + input_audio = input_audio.at[:,0].set(1.) + + variables = model.init({'params': key}, input_audio, N_SAMPLES) + y, mod_vars = model.apply(variables, input_audio, N_SAMPLES, mutable='intermediates') + + assert y.ndim == 2 + assert y.shape[0] == model.getNumOutputs() + assert y.shape[1] == input_audio.shape[1] + assert y.shape[1] == N_SAMPLES + + if args.output is not None: + from scipy.io import wavfile + output_audio = np.array(y).T + wavfile.write(args.output, args.sample_rate, output_audio) + + +if __name__ == '__main__': + import argparse + parser = argparse.ArgumentParser(description='Run a JAX/Flax model converted from Faust code') + parser.add_argument('-sr', '--sample-rate', type=int, default=44100, help='Sample rate (such as 44100)') + parser.add_argument('-d', '--duration', type=float, default=None, help='Output duration in seconds') + parser.add_argument('--random', action='store_true', + help="Whether the default audio is random. By default it's an impulse.") + parser.add_argument('-i', '--input', type=str, default=None, help='Filepath for input audio WAV') + parser.add_argument('-o', '--output', type=str, default=None, help='Filepath for output audio WAV') + + args = parser.parse_args() + + test(args) + print('All done!') diff -Nru faust-2.50.6+ds0/architecture/juce/plugin/plugin.jucer faust-2.54.9+ds0/architecture/juce/plugin/plugin.jucer --- faust-2.50.6+ds0/architecture/juce/plugin/plugin.jucer 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/juce/plugin/plugin.jucer 2022-12-17 10:41:42.000000000 +0000 @@ -65,31 +65,6 @@ - - - - - - - - - - - - - - - - - - - - - - diff -Nru faust-2.50.6+ds0/architecture/juce/README.md faust-2.54.9+ds0/architecture/juce/README.md --- faust-2.50.6+ds0/architecture/juce/README.md 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/juce/README.md 2022-12-17 10:41:42.000000000 +0000 @@ -6,7 +6,7 @@ **faust2juce** uses several UI interfaces, subclasses of the base UI class (defined in the architecture/faust/gui/UI.h header) to link to various JUCE components: - - `JuceGUI.h`: contains the main JuceGUI class (and additional helpers classes) to display Faust UI components (buttons, sliders, bargraphs...) using JUCE widgets + - `JuceGUI.h`: contains the main JuceGUI class (and additional helpers classes) to display Faust UI components (buttons, sliders, bargraphs...) using JUCE widgets. The following `[style:knob]`, `[style:led]`, `[style:numerical]`, `[style:radio]`, `[style:menu]`, `[scale:log]`, `[scale:exp]`, `[tooltip:xx]`, `[hidden:0|1]` metadata are supported. - `JuceOSCUI.h`: allows to link Faust UI components (buttons, sliders, bargraphs...) to the JUCE OSC messaging system, allowing to control them in both directions - `JuceParameterUI.h`: allows to link Faust UI components (buttons, sliders, bargraphs...) with the JUCE AudioParameterFloat/AudioParameterFloat classes - `JuceStateUI.h`: allows to save/restore Faust UI components (buttons, sliders, bargraphs...) values using the JUCE state management system (MemoryInputStream/MemoryOutputStream classes) @@ -52,7 +52,7 @@ - `-magic` : to generate a project using the [PluginGuiMagic GUI builder](https://foleysfinest.com/developer/pluginguimagic/) Tested with PGM version 1.13. Support for Faust components is incomplete. Supporting some features (e.g. visualizers) in PGM requires editing the generated C++ code. - This creates a preprocessor definition "PLUGIN_MAGIC" in the jucer file e.g. using VisualStudio 2019. +This creates a preprocessor definition "PLUGIN_MAGIC" in the jucer file e.g. using VisualStudio 2019. ![image](https://user-images.githubusercontent.com/3178344/125528513-d8f127a0-a896-4f50-8210-ba7b8dcf0386.png) diff -Nru faust-2.50.6+ds0/architecture/juce/standalone/standalone.jucer faust-2.54.9+ds0/architecture/juce/standalone/standalone.jucer --- faust-2.50.6+ds0/architecture/juce/standalone/standalone.jucer 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/juce/standalone/standalone.jucer 2022-12-17 10:41:42.000000000 +0000 @@ -55,30 +55,6 @@ - - - - - - - - - - - - - - - - - - - - - diff -Nru faust-2.50.6+ds0/architecture/minimal.rs faust-2.54.9+ds0/architecture/minimal.rs --- faust-2.50.6+ds0/architecture/minimal.rs 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/minimal.rs 2022-12-17 10:41:42.000000000 +0000 @@ -189,7 +189,18 @@ println!("Faust Rust DSP"); - let mut dsp = Box::new(mydsp::new()); + // Allocation DSP on the heap + let mut dsp; + #[cfg(feature = "default-boxed")] + { + use default_boxed::DefaultBoxed; + dsp = mydsp::default_boxed(); + } + + #[cfg(not(feature = "default-boxed"))] + { + dsp = Box::new(mydsp::new()); + } println!("get_num_inputs: {}", dsp.get_num_inputs()); println!("get_num_outputs: {}", dsp.get_num_outputs()); diff -Nru faust-2.50.6+ds0/architecture/portaudio.rs faust-2.54.9+ds0/architecture/portaudio.rs --- faust-2.50.6+ds0/architecture/portaudio.rs 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/portaudio.rs 2022-12-17 10:41:42.000000000 +0000 @@ -115,7 +115,17 @@ let pa = pa::PortAudio::new()?; // Allocation DSP on the heap - let mut dsp = Box::new(mydsp::new()); + let mut dsp; + #[cfg(feature = "default-boxed")] + { + use default_boxed::DefaultBoxed; + dsp = mydsp::default_boxed(); + } + + #[cfg(not(feature = "default-boxed"))] + { + dsp = Box::new(mydsp::new()); + } println!("Faust Rust code running with Portaudio: sample-rate = {} buffer-size = {}", SAMPLE_RATE, FRAMES_PER_BUFFER); diff -Nru faust-2.50.6+ds0/architecture/soul/hybrid-test1.soul faust-2.54.9+ds0/architecture/soul/hybrid-test1.soul --- faust-2.50.6+ds0/architecture/soul/hybrid-test1.soul 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/soul/hybrid-test1.soul 1970-01-01 00:00:00.000000000 +0000 @@ -1,86 +0,0 @@ - -faust addSynth -{ - import("stdfaust.lib"); - - vol = hslider("volume [unit:dB]", -20, -96, 0, 0.1) : ba.db2linear : si.smoo; - freq = hslider("freq [unit:Hz]", 500, 100, 2000, 1); - - process = vgroup("addSynth", (os.osc(freq) + 0.5*os.osc(2.*freq) + 0.25*os.osc(3.*freq)) * vol); -} - -processor ClassicRingtone -{ - output stream float out; - - void run() - { - int[] pitches = (76, 74, 66, 68, 73, 71, 62, 64, 71, 69, 61, 64, 69); - int[] durations = ( 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 4); - - let samplesPerQuarterNote = int (processor.frequency / 7); - float sinewavePhase; - - loop { - for (int noteIndex = 0; noteIndex < pitches.size; ++noteIndex) - { - let noteFrequency = soul::noteNumberToFrequency (pitches.at (noteIndex)); - let noteLength = samplesPerQuarterNote * durations.at (noteIndex); - let phaseIncrement = float (noteFrequency * twoPi * processor.period); - - loop (noteLength) // play our next note... - { - out << 0.9f * sin (sinewavePhase); - sinewavePhase = addModulo2Pi (sinewavePhase, phaseIncrement); - advance(); - } - } - } - } -} - -faust stereoEcho -{ - import("stdfaust.lib"); - - gain = hslider("gain", 0.5, 0, 1, 0.01); - feedback = hslider("feedback", 0.8, 0, 1, 0.01); - - echo(del_sec, fb, g) = + ~ de.delay(50000, del_samples) * fb * g - with { - del_samples = del_sec*ma.SR; - }; - - process = echo(1.6, 0.6, 0.7), echo(0.7, feedback, gain); -} - -graph sequence [[main]] -{ - // Events to control Faust Synth - input event float32 freq [[ name: "freq", path: "/addSynth/freq", min: 100.0f, max: 2000.0f, init: 500.0f, step: 0.01f, unit: "Hz" ]]; - input event float32 volume [[ name: "volume", path: "/addSynth/volume", min: -96.0f, max: 0.0f, init: -20.0f, step: 0.100000001f, unit: "dB" ]]; - - // Events to control Faust Echo - input event float32 gain [[ name: "gain", path: "/stereoEcho/gain", min: 0.0f, max: 1.0f, init: 0.5, step: 0.01f ]]; - input event float32 feedback [[ name: "feedback", path: "/stereoEcho/feedback", min: 0.0f, max: 1.0f, init: 0.8, step: 0.01f ]]; - - output stream float audioOut0; - output stream float audioOut1; - - connection - { - // Connect to Faust addSynth - volume -> addSynth.volume; - freq -> addSynth.freq; - - // Connect to Faust stereoEcho - feedback -> stereoEcho.feedback; - gain -> stereoEcho.gain; - - addSynth.output0 -> stereoEcho.input0; - ClassicRingtone.out -> stereoEcho.input1; - - stereoEcho.output0 -> audioOut0; - stereoEcho.output1 -> audioOut1; - } -} diff -Nru faust-2.50.6+ds0/architecture/soul/hybrid-test2.soul faust-2.54.9+ds0/architecture/soul/hybrid-test2.soul --- faust-2.50.6+ds0/architecture/soul/hybrid-test2.soul 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/soul/hybrid-test2.soul 1970-01-01 00:00:00.000000000 +0000 @@ -1,56 +0,0 @@ - -faust Osc -{ - import("stdfaust.lib"); - freq = hslider("freq [soul:osc_freq]", 300, 200, 2000, 0.1); - vol = hslider("vol", 0.5, 0, 1, 0.01); - process = os.osc(freq) * vol <: (_,_); -} - -faust Reverb -{ - import("stdfaust.lib"); - process = dm.freeverb_demo; -} - -processor Gain -{ - input stream float volume [[ name: "Gain", min: 0, max: 1, init: 0.1, step: 0.01 ]]; - - input stream float input0; - input stream float input1; - - output stream float output0; - output stream float output1; - - void run() - { - loop { - output0 << input0 * volume; - output1 << input1 * volume; - advance(); - } - } -} - -graph Sequence [[main]] -{ - input Osc.osc_freq; - input Osc.vol; - input Gain.volume; - - output stream float audioOut0; - output stream float audioOut1; - - connection - { - Osc.output0 -> Reverb.input0; - Osc.output1 -> Reverb.input1; - - Reverb.output0 -> Gain.input0; - Reverb.output1 -> Gain.input1; - - Gain.output0 -> audioOut0; - Gain.output1 -> audioOut1; - } -} diff -Nru faust-2.50.6+ds0/architecture/soul/Makefile faust-2.54.9+ds0/architecture/soul/Makefile --- faust-2.50.6+ds0/architecture/soul/Makefile 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/soul/Makefile 1970-01-01 00:00:00.000000000 +0000 @@ -1,26 +0,0 @@ - -LIB ?= /usr/local/lib -DESTDIR ?= -PREFIX ?= /usr/local -MACOSLIBS := -framework CoreAudio -framework AudioUnit -framework CoreServices -framework CoreMIDI -framework CoreFoundation - -prefix := $(DESTDIR)$(PREFIX) - -all: soul-faust-player soul-faust-tester soul-faust-editor - -soul-faust-player: soul-faust-player.cpp - c++ -std=c++17 -O3 -I /usr/local/include -I `pkg-config --cflags --libs samplerate gtk+-2.0 jack` $(MACOSLIBS) soul-faust-player.cpp $(LIB)/libfaust.a `llvm-config --ldflags --libs all --system-libs` -o soul-faust-player - -soul-faust-tester: soul-faust-tester.cpp - c++ -std=c++17 -O3 -I /usr/local/include soul-faust-tester.cpp $(LIB)/libfaust.a `llvm-config --ldflags --libs all --system-libs` -o soul-faust-tester - -soul-faust-editor: soul-faust-editor.cpp - c++ -std=c++17 -O3 -I /usr/local/include soul-faust-editor.cpp $(LIB)/libfaust.a libefsw-static-release.a $(MACOSLIBS) `llvm-config --ldflags --libs all --system-libs` -o soul-faust-editor - -install: - ([ -e soul-faust-player ]) && cp soul-faust-player $(prefix)/bin || echo soul-faust-player not found - ([ -e soul-faust-tester ]) && cp soul-faust-tester $(prefix)/bin || echo soul-faust-tester not found - ([ -e soul-faust-editor ]) && cp soul-faust-editor $(prefix)/bin || echo soul-faust-editor not found - -clean: - rm -f soul-faust-player soul-faust-tester soul-faust-editor diff -Nru faust-2.50.6+ds0/architecture/soul/minimal.soul faust-2.54.9+ds0/architecture/soul/minimal.soul --- faust-2.50.6+ds0/architecture/soul/minimal.soul 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/soul/minimal.soul 1970-01-01 00:00:00.000000000 +0000 @@ -1,43 +0,0 @@ -/************************************************************************ - 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 minimal.soul ****************/ - -/************************************************************************ - 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 . - - 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. - - ************************************************************************ - ************************************************************************/ - - <> -//---------------------------------------------------------------------------- -// FAUST generated signal processor -//---------------------------------------------------------------------------- -<> - -// Nothing more for now - -/******************** END minimal.soul ****************/ diff -Nru faust-2.50.6+ds0/architecture/soul/poly-dsp-effect.soul faust-2.54.9+ds0/architecture/soul/poly-dsp-effect.soul --- faust-2.50.6+ds0/architecture/soul/poly-dsp-effect.soul 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/soul/poly-dsp-effect.soul 1970-01-01 00:00:00.000000000 +0000 @@ -1,240 +0,0 @@ -/************************************************************************ - 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 poly-dsp-effect.soul ****************/ - -/************************************************************************ - 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 . - - 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. - - ************************************************************************ - ************************************************************************/ - - <> -//---------------------------------------------------------------------------- -// FAUST generated signal processor -//---------------------------------------------------------------------------- -<> - -// Decode MIDI events and send freq, gain, gate values to the processor -processor dsp_wrapper -{ - input event - { - soul::note_events::NoteOn noteOn; - soul::note_events::NoteOff noteOff; - soul::note_events::PitchBend pitchBend; - } - - output event float32 freq, gain, gate; - - event noteOn (soul::note_events::NoteOn e) - { - freq << soul::noteNumberToFrequency (e.note); - gain << e.velocity; - gate << 1.0f; - } - - event noteOff (soul::note_events::NoteOff e) - { - gate << 0.0f; - } - - event pitchBend (soul::note_events::PitchBend e) - { - // TODO - } - - void run() - { - advance(); - } -} - -/* - Connect the wrapper with the real processor. - This indirection is done since the "expose control event" model is not yet in place. - So we have some 'ad-hoc' code for now that may change in the future -*/ - -graph dsp_voice -{ - input event - { - soul::note_events::NoteOn noteOn; - soul::note_events::NoteOff noteOff; - soul::note_events::PitchBend pitchBend; - } - - output stream float audioOut0; - output stream float audioOut1; - - connection - { - noteOn -> dsp_wrapper.noteOn; - noteOff -> dsp_wrapper.noteOff; - pitchBend -> dsp_wrapper.pitchBend; - - // This is still the 'hard coded' part - dsp_wrapper.freq -> mydsp.event_freq; - dsp_wrapper.gain -> mydsp.event_gain; - dsp_wrapper.gate -> mydsp.event_gate; - - mydsp.output0 -> audioOut0; - mydsp.output1 -> audioOut1; - } -} - -processor RoundRobinVoiceAllocator (int voiceCount) -{ - input event - { - soul::note_events::NoteOn noteOn; - soul::note_events::NoteOff noteOff; - soul::note_events::PitchBend pitchBend; - } - - output event - { - soul::note_events::NoteOn voiceNoteOn[voiceCount]; - soul::note_events::NoteOff voiceNoteOff[voiceCount]; - soul::note_events::PitchBend voicePitchBend[voiceCount]; - } - - event noteOn (soul::note_events::NoteOn e) - { - wrap allocatedVoice = 0; - var allocatedVoiceAge = voiceInfo[allocatedVoice].voiceAge; - - // Find the oldest voice to reuse - for (int i = 1; i < voiceCount; i++) - { - let age = voiceInfo.at (i).voiceAge; - - if (age < allocatedVoiceAge) - { - allocatedVoiceAge = age; - allocatedVoice = wrap(i); - } - } - - // Update the VoiceInfo for our chosen voice - voiceInfo[allocatedVoice].channel = e.channel; - voiceInfo[allocatedVoice].note = e.note; - voiceInfo[allocatedVoice].voiceAge = nextAllocatedVoiceAge++; - - // Send the note on to the voice - voiceNoteOn[allocatedVoice] << e; - } - - event noteOff (soul::note_events::NoteOff e) - { - // Release all voices associated with this note/channel - wrap voice = 0; - - loop (voiceCount) - { - if (voiceInfo[voice].channel == e.channel - && voiceInfo[voice].note == e.note) - { - // Mark the voice as being unused - voiceInfo[voice].voiceAge = nextUnallocatedVoiceAge++; - voiceNoteOff[voice] << e; - } - - ++voice; - } - } - - event pitchBend (soul::note_events::PitchBend e) - { - // Forward the pitch bend to all notes on this channel - wrap voice = 0; - - loop (voiceCount) - { - if (voiceInfo[voice].channel == e.channel) - voicePitchBend[voice] << e; - - voice++; - } - } - - struct VoiceInfo - { - bool active; - float note; - int channel, voiceAge; - } - - int nextAllocatedVoiceAge = 1000000000; - int nextUnallocatedVoiceAge = 1; - - VoiceInfo[voiceCount] voiceInfo; - - void run() - { - loop { advance(); } - } -} - -// Allocates voices, does dynamic voice management, connect to MIDI parser -graph mydsp_poly_effect [[ main ]] -{ - input event soul::midi::Message midiIn; - output stream float audioOut0; - output stream float audioOut1; - - let - { - midiParser = soul::midi::MPEParser; - voices = dsp_voice[NVOICES]; - voiceAllocator = RoundRobinVoiceAllocator (NVOICES); - } - - connection - { - midiIn -> midiParser.parseMIDI; - - midiParser.eventOut -> voiceAllocator.noteOn, - voiceAllocator.noteOff, - voiceAllocator.pitchBend; - - // Plumb the voice allocator to the voices array - voiceAllocator.voiceNoteOn -> voices.noteOn; - voiceAllocator.voiceNoteOff -> voices.noteOff; - voiceAllocator.voicePitchBend -> voices.pitchBend; - - // Sum the voices audio out to the effect - voices.audioOut0 -> effect.input0; - voices.audioOut1 -> effect.input1; - - // Connect the effect to the output - effect.output0 -> audioOut0; - effect.output1 -> audioOut1; - } -} - -/******************** END poly-dsp-effect.soul ****************/ diff -Nru faust-2.50.6+ds0/architecture/soul/poly-dsp.soul faust-2.54.9+ds0/architecture/soul/poly-dsp.soul --- faust-2.50.6+ds0/architecture/soul/poly-dsp.soul 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/soul/poly-dsp.soul 1970-01-01 00:00:00.000000000 +0000 @@ -1,236 +0,0 @@ -/************************************************************************ - 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 poly-dsp.soul ****************/ - -/************************************************************************ - 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 . - - 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. - - ************************************************************************ - ************************************************************************/ - - <> -//---------------------------------------------------------------------------- -// FAUST generated signal processor -//---------------------------------------------------------------------------- -<> - -// Decode MIDI events and send freq, gain, gate values to the processor -processor dsp_wrapper -{ - input event - { - soul::note_events::NoteOn noteOn; - soul::note_events::NoteOff noteOff; - soul::note_events::PitchBend pitchBend; - } - - output event float32 freq, gain, gate; - - event noteOn (soul::note_events::NoteOn e) - { - freq << soul::noteNumberToFrequency (e.note); - gain << e.velocity; - gate << 1.0f; - } - - event noteOff (soul::note_events::NoteOff e) - { - gate << 0.0f; - } - - event pitchBend (soul::note_events::PitchBend e) - { - // TODO - } - - void run() - { - advance(); - } -} - -/* - Connect the wrapper with the real processor. - This indirection is done since the "expose control event" model is not yet in place. - So we have some 'ad-hoc' code for now that may change in the future -*/ - -graph dsp_voice -{ - input event - { - soul::note_events::NoteOn noteOn; - soul::note_events::NoteOff noteOff; - soul::note_events::PitchBend pitchBend; - } - - output stream float audioOut0; - output stream float audioOut1; - - connection - { - noteOn -> dsp_wrapper.noteOn; - noteOff -> dsp_wrapper.noteOff; - pitchBend -> dsp_wrapper.pitchBend; - - // This is still the 'hard coded' part - dsp_wrapper.freq -> mydsp.event_freq; - dsp_wrapper.gain -> mydsp.event_gain; - dsp_wrapper.gate -> mydsp.event_gate; - - mydsp.output0 -> audioOut0; - mydsp.output1 -> audioOut1; - } -} - -processor RoundRobinVoiceAllocator (int voiceCount) -{ - input event - { - soul::note_events::NoteOn noteOn; - soul::note_events::NoteOff noteOff; - soul::note_events::PitchBend pitchBend; - } - - output event - { - soul::note_events::NoteOn voiceNoteOn[voiceCount]; - soul::note_events::NoteOff voiceNoteOff[voiceCount]; - soul::note_events::PitchBend voicePitchBend[voiceCount]; - } - - event noteOn (soul::note_events::NoteOn e) - { - wrap allocatedVoice = 0; - var allocatedVoiceAge = voiceInfo[allocatedVoice].voiceAge; - - // Find the oldest voice to reuse - for (int i = 1; i < voiceCount; i++) - { - let age = voiceInfo.at (i).voiceAge; - - if (age < allocatedVoiceAge) - { - allocatedVoiceAge = age; - allocatedVoice = wrap(i); - } - } - - // Update the VoiceInfo for our chosen voice - voiceInfo[allocatedVoice].channel = e.channel; - voiceInfo[allocatedVoice].note = e.note; - voiceInfo[allocatedVoice].voiceAge = nextAllocatedVoiceAge++; - - // Send the note on to the voice - voiceNoteOn[allocatedVoice] << e; - } - - event noteOff (soul::note_events::NoteOff e) - { - // Release all voices associated with this note/channel - wrap voice = 0; - - loop (voiceCount) - { - if (voiceInfo[voice].channel == e.channel - && voiceInfo[voice].note == e.note) - { - // Mark the voice as being unused - voiceInfo[voice].voiceAge = nextUnallocatedVoiceAge++; - voiceNoteOff[voice] << e; - } - - ++voice; - } - } - - event pitchBend (soul::note_events::PitchBend e) - { - // Forward the pitch bend to all notes on this channel - wrap voice = 0; - - loop (voiceCount) - { - if (voiceInfo[voice].channel == e.channel) - voicePitchBend[voice] << e; - - voice++; - } - } - - struct VoiceInfo - { - bool active; - float note; - int channel, voiceAge; - } - - int nextAllocatedVoiceAge = 1000000000; - int nextUnallocatedVoiceAge = 1; - - VoiceInfo[voiceCount] voiceInfo; - - void run() - { - loop { advance(); } - } -} - -// Allocates voices, does dynamic voice management, connect to MIDI parser -graph mydsp_poly [[ main ]] -{ - input event soul::midi::Message midiIn; - output stream float audioOut0; - output stream float audioOut1; - - let - { - midiParser = soul::midi::MPEParser; - voices = dsp_voice[NVOICES]; - voiceAllocator = RoundRobinVoiceAllocator (NVOICES); - } - - connection - { - midiIn -> midiParser.parseMIDI; - - midiParser.eventOut -> voiceAllocator.noteOn, - voiceAllocator.noteOff, - voiceAllocator.pitchBend; - - // Plumb the voice allocator to the voices array - voiceAllocator.voiceNoteOn -> voices.noteOn; - voiceAllocator.voiceNoteOff -> voices.noteOff; - voiceAllocator.voicePitchBend -> voices.pitchBend; - - // Sum the voices audio out to the output - voices.audioOut0 -> audioOut0; - voices.audioOut1 -> audioOut1; - } -} - -/******************** END poly-dsp.soul ****************/ \ No newline at end of file diff -Nru faust-2.50.6+ds0/architecture/soul/README.md faust-2.54.9+ds0/architecture/soul/README.md --- faust-2.50.6+ds0/architecture/soul/README.md 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/soul/README.md 1970-01-01 00:00:00.000000000 +0000 @@ -1,161 +0,0 @@ -# faust2soul - -The **faust2soul** tool compiles a Faust DSP program in a folder containing the SOUL source code and SOUL patch. The result can be a monophonic DSP or a MIDI controllable polyphonic one (when the DSP describes an instrument, following the `freq, gain, gate` [parameter naming convention](https://faust.grame.fr/doc/manual/index.html#midi-polyphony-support)). The resulting SOUL code can be played using the **soul** runtime, or by pasting and compiling the code in the [SOUL Playground](https://soul.dev/playground): - -`faust2soul [-midi] [-nvoices ] [-effect auto|] [-juce] [-dsp] [-play] [additional Faust options (-cn foo -double...)] ` - -Here are the available options: - -- `-midi to activate MIDI control` -- `-nvoices to produce a polyphonic self-contained DSP with voices, ready to be used with MIDI` -- `-effect to produce a polyphonic DSP connected to a global output effect, ready to be used with MIDI` -- `-effect auto to produce a polyphonic DSP connected to a global output effect defined as 'effect' in , ready to be used with MIDI` -- `-juce to create a JUCE project` -- `-dsp to create a 'dsp' compatible subclass` -- `-play to start the 'soul' runtime with the generated SOUL patch` - -So for instance: - -- `faust2soul noise.dsp` to produce two noise.soul and noise.soulpatch files -- `faust2soul -play osc.dsp` to produce two osc.soul and osc.soulpatch files and play the osc.soulpatch -- `faust2soul -midi -nvoices 16 -play clarinetMIDI.dsp` to produce a 16 voices polyphonic MIDI aware intrument as two clarinetMIDI.soul and clarinetMIDI.soulpatch files and play the clarinetMIDI.soulpatch -- `faust2soul -midi -nvoices 16 -effect freeverb.dsp -play violinMIDI.dsp` to produce a 16 voices polyphonic MIDI aware intrument with a global effect as two violinMIDI.soul and violinMIDI.soulpatch files and play the violinMIDI.soulpatch - -# soul-faust-player - -The **soul-faust-player** tool loads a Faust DSP file, a SOUL patch or an hybrid Faust/SOUL code file, wraps it as a Faust DSP object, and runs it in the Faust runtime audio/control machinery. - -`soul-faust-player (pure Faust code), (pure SOUL patch) or (pure SOUL code or Faust/SOUL hybrid code)` - -So for instance: - -- `faust2soul clarinetMIDI.dsp` to produce the two `clarinetMIDI.soul` and `clarinetMIDI.soulpatch` files - -Then: - -- `soul-faust-player clarinetMIDI.dsp` to run the `clarinetMIDI.dsp` file (only containing Faust code) -- `soul-faust-player clarinetMIDI.soulpatch` to run the `clarinetMIDI.soulpatch` file - -Or: - -- `soul-faust-player clarinetMIDI.soul` to run the `clarinetMIDI.soul` file (only containing the SOUL code) -- `soul-faust-player hybrid-test1.soul` to run an hybrid `hybrid-test1.soul` file containing both Faust and SOUL sections. Two `hybrid.soul` (containing the original SOUL sections and the Faust => SOUL generated sections) and an `hybrid.soulpatch` files will be generated in the process. - -# soul-faust-tester - -The **soul-faust-tester** tool allows to test DSP CPU usage of Faust and SOUL programs, dynamically compiling them, and running them in the Faust runtime or **soul** runtime. It measures the DSP CPU usage as MBytes/sec and % of audio bandwidth at 44.1 kHz. - -`soul-faust-tester [-bs ] [-control] [Faust options : any option (e.g. -vec -vs 8...)] ` - -Here are the available options: - -- `-bs to set the maximum buffer-size in frames` -- `-control to update all controllers with random values at each cycle` - -So for instance: - -- `soul-faust-tester foo.dsp` to test 1) the Faust DSP code compiled to LLVM-IR and JITted to native code, then running in the Faust runtime, 2) the Faust DSP code compiled to SOUL, then compiled to LLVM-IR and JITted to native code, and running in the **soul** runtime. - -- `soul-faust-tester foo.soulpatch` to test a SOUL patch compiled to LLVM-IR and JITted to native code, and running in the **soul** runtime. - -# soul-faust-editor - -The **soul-faust-editor** tool loads an hybrid Faust/SOUL code file and compiles it in a SOUL patch each time the source file content changes. It can be used together with the **soul** runtime or any SOUL aware plugin to create a *Faust/SOUL => SOUL => executable code* edit loop. The SOUL generated files can be set using the`-o ` option and are named `hybrid.soul` and `hybrid.soulpatch` by default. - -`soul-faust-editor [Faust options : any option (e.g. -ftz 1...)] -o ` - -So for instance to setup a Faust/SOUL hybrid file edition session: - -- `soul-faust-editor hybrid-test2.soul` to start editing an hybrid Faust/SOUL code -- `soul play hybrid.soulpatch` to play the SOUL dynamically generated `hybrid.soulpatch` - -## Hybrid Faust/SOUL Syntax - -A Faust block uses the following syntax: - - ``` -faust Name -{ - ... Faust code... -} - ``` - -It will be compiled in SOUL code as a `processor Name { ...SOUL code... } ` and inserted back in the resulting SOUL file. Here is a real example: - - ``` -faust Osc -{ - import("stdfaust.lib"); - freq = hslider("freq [soul:osc_freq]", 300, 200, 2000, 0.1); - vol = hslider("vol", 0.5, 0, 1, 0.01); - process = os.osc(freq) * vol <: (_,_); -} - ``` - - By convention, Faust processors audio inputs are numbered `input0/input1..inputN` and audio outputs `output0/output1..outputN`. So a given `faust Foo {...}` block can be used in the graph section with: `Foo.input0`, `Foo.input1`, `Foo.ouput0`, `Foo.output1` for instance. - -Control parameters (button, slider, nentry) are using their label name, or a possible *alias* if the `[soul:alias]` metadata appears in the label string. - -## Example of an hybrid file - -The following example combines: - -- an `Osc` Faust block with *freq (using an 'osc_freq' alias)* and *vol* controllers -- a `Gain` SOUL processor with a *volume* controller -- a `Sequence` graph connecting the Faust osc in the SOUL gain and exposing the three controllers - - ``` -faust Osc -{ - import("stdfaust.lib"); - freq = hslider("freq [soul:osc_freq]", 300, 200, 2000, 0.1); - vol = hslider("vol", 0.5, 0, 1, 0.01); - process = os.osc(freq) * vol <: (_,_); -} - -processor Gain -{ - input stream float volume [[ name: "Gain", min: 0, max: 1, init: 0.1, step: 0.01 ]]; - - input stream float input0; - input stream float input1; - - output stream float output0; - output stream float output1; - - void run() - { - loop { - output0 << input0 * volume; - output1 << input1 * volume; - advance(); - } - } -} - -graph Sequence [[main]] -{ - // Used in 'hslider' label with [soul:osc_freq] metadata in 'Faust Osc {...}' block - input Osc.osc_freq; - // Used as 'hslider' label in 'Faust Osc {...}' block - input Osc.vol; - // Using in SOUL 'processor Gain {...}' block - input Gain.volume; - - output stream float audioOut0; - output stream float audioOut1; - - connection - { - // Faust Osc {...} audio outputs are output0/output1...outputN - Osc.output0 -> Gain.input0; - Osc.output1 -> Gain.input1; - - Gain.output0 -> audioOut0; - Gain.output1 -> audioOut1; - } -} - ``` - -**Note**: the code has a dependency with the [efsw](https://github.com/havoc-io/efsw) library which has to be installed before compilation. - diff -Nru faust-2.50.6+ds0/architecture/soul/soul-faust-editor.cpp faust-2.54.9+ds0/architecture/soul/soul-faust-editor.cpp --- faust-2.50.6+ds0/architecture/soul/soul-faust-editor.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/soul/soul-faust-editor.cpp 1970-01-01 00:00:00.000000000 +0000 @@ -1,146 +0,0 @@ -/************************************************************************ - FAUST Architecture File - Copyright (C) 2021 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 . - - 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 -#include -#include -#include -#include - -#include "faust/dsp/soulpatch-dsp.h" -#include "faust/dsp/llvm-dsp.h" -#include "faust/misc.h" - -using namespace std; - -static bool endWith(const string& str, const string& suffix) -{ - size_t i = str.rfind(suffix); - return (i != string::npos) && (i == (str.length() - suffix.length())); -} - -struct HybridEditor { - - string fInFilename; - string fOutFilename; - int fArgc1; - const char** fArgv1; - efsw_watcher fEfsw; - - HybridEditor(const string& in_filename, - const string& out_filename, - int argc1, - const char* argv1[]) - :fInFilename(in_filename), fOutFilename(out_filename), fArgc1(argc1), fArgv1(argv1) - { - char temp[PATH_MAX + 1]; - char* path = realpath(in_filename.c_str(), temp); - std::string dir = dirname(path); - - fEfsw = efsw_create(false); - efsw_addwatch(fEfsw, dir.c_str(), watchCallback, false, this); - efsw_watch(fEfsw); - - compilePatch(); - - cout << "Type 'q' to Quit\n"; - char c; - while ((c = getchar()) && (c != 'q')) {} - } - - virtual ~HybridEditor() - { - efsw_release(fEfsw); - } - - void compilePatch() - { - cout << "compilePatch : '" << fInFilename << "' to '" << fOutFilename << "' and '" << fOutFilename + "patch'" << endl; - // We have a pure SOUL file or a Faust/SOUL file, parse it, compile the Faust part to SOUL, generate the SOUL result - faust_soul_parser parser; - if (!parser.parseSOULFile(fInFilename, fOutFilename, fArgc1, fArgv1)) { - cerr << "ERROR : file '" << fInFilename << "' cannot be opened or compiled!\n"; - return; - } - - // Generate "soulpatch" file - parser.createSOULPatch(fOutFilename); - } - - static void watchCallback(efsw_watcher watcher, - efsw_watchid watchid, - const char* dir, - const char* filename, - enum efsw_action action, - const char* old_filename, - void* param) - { - HybridEditor* editor = (HybridEditor*)param; - if (action == EFSW_ADD - || action == EFSW_DELETE - || action == EFSW_MODIFIED - || action == EFSW_MOVED) { - // Check filename - if (string(filename) == editor->fInFilename) { - editor->compilePatch(); - } - } - } - -}; - -int main(int argc, char* argv[]) -{ - if (isopt(argv, "-h") || isopt(argv, "-help")) { - cout << "Copyright (c) 2021 Grame, version 0.1" << endl; - cout << "Usage: soul-faust-editor [Faust options : any option (e.g. -ftz 1...)] -o " << endl; - exit(-1); - } - - string in_filename; - string out_filename = "hybrid.soul"; - int argc1 = 0; - const char* argv1[64]; - for (int i = 1; i < argc; i++) { - if (endWith(string(argv[i]), ".soul")) { - in_filename = argv[i]; - continue; - } else if (string(argv[i]) == "-o") { - out_filename = argv[i+1]; - i++; - continue; - } - argv1[argc1++] = argv[i]; - } - - cout << "Libfaust version : " << getCLibFaustVersion() << endl; - - if (endWith(in_filename, "soul")) { - HybridEditor editor(in_filename, out_filename, argc1, argv1); - } else { - cout << "ERROR : incorrect file type" << endl; - exit(-1); - } - - return 0; -} diff -Nru faust-2.50.6+ds0/architecture/soul/soul-faust-player.cpp faust-2.54.9+ds0/architecture/soul/soul-faust-player.cpp --- faust-2.50.6+ds0/architecture/soul/soul-faust-player.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/soul/soul-faust-player.cpp 1970-01-01 00:00:00.000000000 +0000 @@ -1,144 +0,0 @@ -/************************************************************************ - 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 . - - 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 -#include - -#include "faust/gui/GTKUI.h" -#include "faust/audio/jack-dsp.h" -#include "faust/dsp/soulpatch-dsp.h" -#include "faust/dsp/libfaust.h" -#include "faust/misc.h" -#include "faust/midi/rt-midi.h" -#include "faust/midi/RtMidi.cpp" - -using namespace std; - -list GUI::fGuiList; -ztimedmap GUI::gTimedZoneMap; - -#define FAUST_FILE "faust.soul" -#define FAUST_PATCH_FILE "faust.soulpatch" - -#define HYBRID_FILE "hybrid.soul" -#define HYBRID_PATCH_FILE "hybrid.soulpatch" - -static bool endWith(const string& str, const string& suffix) -{ - size_t i = str.rfind(suffix); - return (i != string::npos) && (i == (str.length() - suffix.length())); -} - -int main(int argc, char* argv[]) -{ - if (isopt(argv, "-h") || isopt(argv, "-help")) { - cout << "soul-faust-player (pure Faust code), (pure SOUL patch) or (pure SOUL code or Faust/SOUL hybrid code)" << endl; - exit(-1); - } - - char* filename = argv[argc-1]; - string real_file; - - int argc1 = 0; - const char* argv1[64]; - for (int i = 1; i < argc-1; i++) { - argv1[argc1++] = argv[i]; - } - - if (endWith(filename, ".dsp")) { - - // We have a pure Faust file, compile it to SOUL - faust_soul_parser parser; - if (!parser.generateSOULFile(filename, FAUST_FILE, argc1, argv1)) { - cerr << "ERROR : file '" << filename << "' cannot be opened or compiled!\n"; - exit(-1); - } - - // Generate "soulpatch" file - parser.createSOULPatch(FAUST_FILE); - real_file = FAUST_PATCH_FILE; - - } else if (endWith(filename, ".soul")) { - - // We have a pure SOUL file or a Faust/SOUL file, parse it, compile the Faust part to SOUL, generate the SOUL result - faust_soul_parser parser; - if (!parser.parseSOULFile(filename, HYBRID_FILE, argc1, argv1)) { - cerr << "ERROR : file '" << filename << "' cannot be opened or compiled!\n"; - exit(-1); - } - - // Generate "soulpatch" file - parser.createSOULPatch(HYBRID_FILE); - real_file = HYBRID_PATCH_FILE; - - } else if (endWith(filename, ".soulpatch")) { - - // We have a SOUL patchfile - real_file = filename; - - } else { - cerr << "Unsupported file extension" << endl; - exit(1); - } - - try { - string error_msg; - soul_dsp_factory* factory = createSOULDSPFactoryFromFile(real_file, argc, (const char**)argv, error_msg); - if (!factory) { - cerr << "Cannot create factory : " << error_msg; - exit(1); - } - soulpatch_dsp* DSP = factory->createDSPInstance(); - - cout << "getNumInputs " << DSP->getNumInputs() << endl; - cout << "getNumOutputs " << DSP->getNumOutputs() << endl; - - jackaudio audio; - audio.init(filename, DSP); - - // Has to be done after init - GTKUI interface(filename, &argc, &argv); - DSP->buildUserInterface(&interface); - - // MIDI handling - rt_midi midi_handler(filename, false, true); - DSP->setMidiHandler(&midi_handler); - - midi_handler.startMidi(); - audio.start(); - - interface.run(); - - midi_handler.stopMidi(); - audio.stop(); - - // Cleanup - delete DSP; - delete factory; - } catch (...) { - cerr << "ERROR : cannot allocate soulpatch_dsp\n"; - exit(-1); - } - - return 0; -} diff -Nru faust-2.50.6+ds0/architecture/soul/soul-faust-tester.cpp faust-2.54.9+ds0/architecture/soul/soul-faust-tester.cpp --- faust-2.50.6+ds0/architecture/soul/soul-faust-tester.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/soul/soul-faust-tester.cpp 1970-01-01 00:00:00.000000000 +0000 @@ -1,130 +0,0 @@ -/************************************************************************ - 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 . - - 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 -#include - -#include "faust/dsp/soulpatch-dsp.h" -#include "faust/dsp/dsp-optimizer.h" -#include "faust/misc.h" - -#define FAUST_FILE "faust.soul" -#define FAUST_PATCH_FILE "faust.soulpatch" - -using namespace std; - -static int buffer_size = 512; -static bool is_control = false; - -static bool endWith(const string& str, const string& suffix) -{ - size_t i = str.rfind(suffix); - return (i != string::npos) && (i == (str.length() - suffix.length())); -} - -static void measureDSP(const string& filename, dsp* DSP) -{ - // Buffer_size and duration in sec of measure, no trace and activated control - measure_dsp mes(DSP, buffer_size, 5., false, is_control); - mes.measure(); - cout << filename << " : " << mes.getStats() << " MBytes/sec (DSP CPU % : " << (mes.getCPULoad() * 100) << " at 44100 Hz)" << endl; - FAUSTBENCH_LOG(mes.getStats()); -} - -static void testFaust(const string& filename, int argc1, const char* argv1[]) -{ - // Faust compilation and test - string error_msg; - llvm_dsp_factory* factory = createDSPFactoryFromFile(filename, argc1, argv1, "", error_msg, -1); - if (!factory) { - cerr << "ERROR : file '" << filename << "' cannot be opened with " << error_msg << "\n"; - exit(-1); - } - measureDSP(filename, factory->createDSPInstance()); - deleteDSPFactory(factory); -} - -static void testSOULPatch(const string& filename, int argc1, const char* argv1[]) -{ - // SOUL compilation and test - string error_msg; - soul_dsp_factory* factory = createSOULDSPFactoryFromFile(filename, argc1, argv1, error_msg); - if (!factory) { - cerr << "ERROR : file '" << filename << "' : " << error_msg << "\n"; - exit(-1); - } - - measureDSP(filename, factory->createDSPInstance()); - delete factory; -} - -static void testSOUL(const string& filename, int argc1, const char* argv1[]) -{ - // Faust => SOUL compilation - faust_soul_parser parser; - if (!parser.generateSOULFile(filename, FAUST_FILE, argc1, argv1)) { - cerr << "ERROR : file '" << filename << "' cannot be opened or compiled! \n"; - exit(-1); - } - - // Generate "soulpatch" file - parser.createSOULPatch(FAUST_FILE); - - testSOULPatch(FAUST_PATCH_FILE, argc1, argv1); -} - -int main(int argc, char* argv[]) -{ - if (isopt(argv, "-h") || isopt(argv, "-help")) { - cout << "soul-faust-tester [-bs ] [-control] [Faust options : any option (e.g. -vec -vs 8...)] foo.dsp|foo.soulpatch" << endl; - cout << "Use '-bs ' to set the maximum buffer-size in frames\n"; - cout << "Use '-control' to update all controllers with random values at each cycle\n"; - exit(-1); - } - - buffer_size = lopt(argv, "-bs", 512); - is_control = isopt(argv, "-control"); - cout << "buffer_size = " << buffer_size << endl; - - char* filename = argv[argc-1]; - int argc1 = 0; - const char* argv1[64]; - for (int i = 1; i < argc-1; i++) { - if (string(argv[i]) == "-control") { - continue; - } else if (string(argv[i]) == "-bs") { - i++; - continue; - } - argv1[argc1++] = argv[i]; - } - - if (endWith(filename, "soulpatch")) { - testSOULPatch(filename, argc1, argv1); - } else { - testFaust(filename, argc1, argv1); - testSOUL(filename, argc1, argv1); - } - - return 0; -} diff -Nru faust-2.50.6+ds0/architecture/teensy/teensy.h faust-2.54.9+ds0/architecture/teensy/teensy.h --- faust-2.50.6+ds0/architecture/teensy/teensy.h 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/teensy/teensy.h 2022-12-17 10:41:42.000000000 +0000 @@ -31,6 +31,8 @@ #include "AudioStream.h" #include "Audio.h" +#define fprintf(X, Y, Z) Serial.printf(Y, Z) + class dsp; class MapUI; diff -Nru faust-2.50.6+ds0/architecture/vst.cpp faust-2.54.9+ds0/architecture/vst.cpp --- faust-2.50.6+ds0/architecture/vst.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/architecture/vst.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -291,7 +291,7 @@ if (m_dsp->getNumInputs() == 0) { suspend(); // Synths start out quiet } -} // end of Faust constructor +} //---------------------------------------------------------------------------- Faust::~Faust() @@ -310,7 +310,7 @@ delete m_dspUI; delete m_dsp; -} // end of Faust destructor +} //----------------------------------------------------------------------------- void Faust::setProgram(VstInt32 program) @@ -330,7 +330,7 @@ #endif curProgram = program; // curProgram defined in audioeffect.h -} // end of setProgram +} //---------------------------------------------------------------------------- void Faust::setProgramName(const char* name) @@ -356,7 +356,7 @@ TRACE( fprintf(stderr, "Called getParameterLabel for parameter %d, returning %s\n", index, label) ); -} // end of getParameterLabel +} //---------------------------------------------------------------------------- void Faust::getParameterDisplay(VstInt32 index, char *text) @@ -376,10 +376,9 @@ } else { vst_strncpy(label, "IndexOutOfRange", kVstMaxParamStrLen); } -} // end of getParamterName - -//-------------------- +} +//---------------------------------------------------------------------------- bool Faust::getParameterProperties(VstInt32 index, VstParameterProperties* properties) { if (index < 0 || index >= m_dspUI->GetNumParams()) { @@ -407,7 +406,7 @@ } return true; -} // end of getParameterProperties +} //---------------------------------------------------------------------------- void Faust::setParameter(VstInt32 index, float value) @@ -425,7 +424,7 @@ index, i, value) ); m_voices[i]->SetValue(index, value); } -} // end of setParameter +} //---------------------------------------------------------------------------- float Faust::getParameter(VstInt32 index) @@ -477,13 +476,16 @@ return false; } +//----------------------------------------------------------------------------- const char* Faust::getMetadata(const char* key, const char* defaultString) { Meta meta; - mydsp tmp_dsp; - tmp_dsp.metadata(&meta); - return meta.get(key, defaultString); -} // end of getMetadata + mydsp* tmp = new mydsp; + tmp->metadata(&meta); + const char* res = meta.get(key, defaultString); + delete tmp; + return res; +} //----------------------------------------------------------------------------- bool Faust::getEffectName(char* name) @@ -532,7 +534,7 @@ } return -1; // explicitly can't do; 0 => don't know -} // end of canDo +} //---------------------------------------------------------------------------- VstInt32 Faust::getNumMidiInputChannels() @@ -629,13 +631,15 @@ // We're a synth . . . synthProcessReplacing(inputs, outputs, sampleFrames); } -} // end of processReplacing +} +//---------------------------------------------------------------------------- inline float midiToFreq(int note) { return 440.0f*powf(2.0f,(((float)note)-69.0f)/12.0f); } +//---------------------------------------------------------------------------- void Faust::synthProcessReplacing(FAUSTFLOAT** inputs, FAUSTFLOAT** outputs, VstInt32 sampleFrames) { @@ -745,8 +749,9 @@ compute(inputs, outputs, sampleFrames); } -} // end of synthProcessReplacing +} +//---------------------------------------------------------------------------- void Faust::compute(FAUSTFLOAT** inputs, FAUSTFLOAT** outputs, VstInt32 sampleFrames) { @@ -811,7 +816,7 @@ outputs[i][frame] /= (FAUSTFLOAT)sqrt(MAX_POLYPHONY); } } -} // end of compute +} //----------------------------------------------------------------------------- VstInt32 Faust::processEvents(VstEvents* ev) @@ -893,15 +898,15 @@ } //---------------------------------------------------------------------------- - void Faust::bendPitch(float bend) { TRACE( fprintf(stderr, "Bending pitch by %f\n", bend) ); for (unsigned int i = 0; i < MAX_POLYPHONY; ++i) { m_voices[i]->setPitchBend(bend); } -} // end of Faust::bendPitch +} +//---------------------------------------------------------------------------- void Faust::noteOn (VstInt32 note, VstInt32 velocity, VstInt32 delta) { #ifdef DEBUG @@ -910,7 +915,7 @@ m_currentNotes.push_back(note); m_currentVelocities.push_back(velocity); m_currentDeltas.push_back(delta); -} // end of noteOn +} //----------------------------------------------------------------------------- void Faust::noteOff(VstInt32 note, VstInt32 delta) @@ -936,7 +941,7 @@ m_releasedVoices.push_back(voice); } } -} // end of Faust::allNotesOff +} /********************END ARCHITECTURE SECTION (part 2/2)****************/ diff -Nru faust-2.50.6+ds0/build/backends/all.cmake faust-2.54.9+ds0/build/backends/all.cmake --- faust-2.50.6+ds0/build/backends/all.cmake 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/build/backends/all.cmake 2022-12-17 10:41:42.000000000 +0000 @@ -10,14 +10,16 @@ set ( C_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include C backend" FORCE ) set ( CPP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include CPP backend" FORCE ) +set ( CMAJOR_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Cmajor backend" FORCE ) set ( CSHARP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include CSharp backend" FORCE ) -set ( DLANG_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include DLANG backend" FORCE ) +set ( DLANG_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Dlang backend" FORCE ) set ( FIR_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include FIR backend" FORCE ) -set ( INTERP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include INTERPRETER backend" FORCE ) +set ( INTERP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Interpreter backend" FORCE ) set ( JAVA_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include JAVA backend" FORCE ) -set ( JULIA_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Julia backend" FORCE ) +set ( JAX_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include JAX backend" FORCE ) +set ( JULIA_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Julia backend" FORCE ) set ( LLVM_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include LLVM backend" FORCE ) set ( OLDCPP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include old CPP backend" FORCE ) set ( RUST_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Rust backend" FORCE ) -set ( SOUL_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include SOUL backend" FORCE ) +set ( TEMPLATE_BACKEND OFF CACHE STRING "Include Template backend" FORCE ) set ( WASM_BACKEND COMPILER STATIC DYNAMIC WASM CACHE STRING "Include WASM backend" FORCE ) diff -Nru faust-2.50.6+ds0/build/backends/backends.cmake faust-2.54.9+ds0/build/backends/backends.cmake --- faust-2.50.6+ds0/build/backends/backends.cmake 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/build/backends/backends.cmake 2022-12-17 10:41:42.000000000 +0000 @@ -9,14 +9,17 @@ set ( C_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include C backend" FORCE ) set ( CPP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include CPP backend" FORCE ) -set ( CSHARP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include CSharp backend" FORCE ) -set ( DLANG_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include DLANG backend" FORCE ) +set ( CMAJOR_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Cmajor backend" FORCE ) +set ( CSHARP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include CSharp backend" FORCE ) +set ( DLANG_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Dlang backend" FORCE ) set ( FIR_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include FIR backend" FORCE ) -set ( INTERP_BACKEND OFF CACHE STRING "Include INTERPRETER backend" FORCE ) +set ( INTERP_BACKEND OFF CACHE STRING "Include Interpreter backend" FORCE ) set ( JAVA_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include JAVA backend" FORCE ) +set ( JAX_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include JAX backend" FORCE ) set ( JULIA_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Julia backend" FORCE ) set ( LLVM_BACKEND STATIC DYNAMIC CACHE STRING "Include LLVM backend" FORCE ) set ( OLDCPP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include old CPP backend" FORCE ) set ( RUST_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Rust backend" FORCE ) -set ( SOUL_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include SOUL backend" FORCE ) +# Template is deactivated +set ( TEMPLATE_BACKEND OFF CACHE STRING "Include Template backend" FORCE ) set ( WASM_BACKEND COMPILER STATIC DYNAMIC WASM CACHE STRING "Include WASM backend" FORCE ) diff -Nru faust-2.50.6+ds0/build/backends/interp.cmake faust-2.54.9+ds0/build/backends/interp.cmake --- faust-2.50.6+ds0/build/backends/interp.cmake 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/build/backends/interp.cmake 2022-12-17 10:41:42.000000000 +0000 @@ -9,14 +9,17 @@ set ( C_BACKEND OFF CACHE STRING "Include C backend" FORCE ) set ( CPP_BACKEND OFF CACHE STRING "Include CPP backend" FORCE ) +set ( CMAJOR_BACKEND OFF CACHE STRING "Include Cmajor backend" FORCE ) set ( CSHARP_BACKEND OFF CACHE STRING "Include CSharp backend" FORCE ) -set ( DLANG_BACKEND OFF CACHE STRING "Include DLANG backend" FORCE ) +set ( DLANG_BACKEND OFF CACHE STRING "Include Dlang backend" FORCE ) set ( FIR_BACKEND OFF CACHE STRING "Include FIR backend" FORCE ) -set ( INTERP_BACKEND STATIC CACHE STRING "Include INTERPRETER backend" FORCE ) +set ( INTERP_BACKEND STATIC CACHE STRING "Include Interpreter backend" FORCE ) set ( JAVA_BACKEND OFF CACHE STRING "Include JAVA backend" FORCE ) +set ( JAX_BACKEND OFF CACHE STRING "Include JAX backend" FORCE ) set ( JULIA_BACKEND OFF CACHE STRING "Include Julia backend" FORCE ) set ( LLVM_BACKEND OFF CACHE STRING "Include LLVM backend" FORCE ) set ( OLDCPP_BACKEND OFF CACHE STRING "Include old CPP backend" FORCE ) set ( RUST_BACKEND OFF CACHE STRING "Include Rust backend" FORCE ) -set ( SOUL_BACKEND OFF CACHE STRING "Include SOUL backend" FORCE ) +# Template is deactivated +set ( TEMPLATE_BACKEND OFF CACHE STRING "Include Template backend" FORCE ) set ( WASM_BACKEND OFF CACHE STRING "Include WASM backend" FORCE ) diff -Nru faust-2.50.6+ds0/build/backends/ios.cmake faust-2.54.9+ds0/build/backends/ios.cmake --- faust-2.50.6+ds0/build/backends/ios.cmake 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/build/backends/ios.cmake 2022-12-17 10:41:42.000000000 +0000 @@ -7,19 +7,22 @@ # DYNAMIC embed the backend in the faust dynamic library # WASM embed the backend in the faust wasm library -set ( IOS ON CACHE BOOL "Compiles for iOS" FORCE ) +set ( IOS ON CACHE BOOL "Compiles for iOS" FORCE ) set ( C_BACKEND OFF CACHE STRING "Include C backend" FORCE ) set ( CPP_BACKEND OFF CACHE STRING "Include CPP backend" FORCE ) +set ( CMAJOR_BACKEND OFF CACHE STRING "Include Cmajor backend" FORCE ) set ( CSHARP_BACKEND OFF CACHE STRING "Include CSharp backend" FORCE ) -set ( DLANG_BACKEND OFF CACHE STRING "Include DLANG backend" FORCE ) +set ( DLANG_BACKEND OFF CACHE STRING "Include Dlang backend" FORCE ) set ( FIR_BACKEND OFF CACHE STRING "Include FIR backend" FORCE ) -set ( INTERP_BACKEND STATIC CACHE STRING "Include INTERPRETER backend" FORCE ) +set ( INTERP_BACKEND STATIC CACHE STRING "Include Interpreter backend" FORCE ) set ( JAVA_BACKEND OFF CACHE STRING "Include JAVA backend" FORCE ) +set ( JAX_BACKEND OFF CACHE STRING "Include JAX backend" FORCE ) set ( JULIA_BACKEND OFF CACHE STRING "Include Julia backend" FORCE ) set ( LLVM_BACKEND OFF CACHE STRING "Include LLVM backend" FORCE ) set ( OLDCPP_BACKEND OFF CACHE STRING "Include old CPP backend" FORCE ) set ( RUST_BACKEND OFF CACHE STRING "Include Rust backend" FORCE ) -set ( SOUL_BACKEND OFF CACHE STRING "Include SOUL backend" FORCE ) +# Template is deactivated +set ( TEMPLATE_BACKEND OFF CACHE STRING "Include Rust backend" FORCE ) set ( WASM_BACKEND OFF CACHE STRING "Include WASM backend" FORCE ) diff -Nru faust-2.50.6+ds0/build/backends/light.cmake faust-2.54.9+ds0/build/backends/light.cmake --- faust-2.50.6+ds0/build/backends/light.cmake 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/build/backends/light.cmake 2022-12-17 10:41:42.000000000 +0000 @@ -9,15 +9,18 @@ set ( C_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include C backend" FORCE ) set ( CPP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include CPP backend" FORCE ) +set ( CMAJOR_BACKEND OFF CACHE STRING "Include Cmajor backend" FORCE ) set ( CSHARP_BACKEND OFF CACHE STRING "Include CSharp backend" FORCE ) -set ( DLANG_BACKEND OFF CACHE STRING "Include DLANG backend" FORCE ) +set ( DLANG_BACKEND OFF CACHE STRING "Include Dlang backend" FORCE ) set ( FIR_BACKEND OFF CACHE STRING "Include FIR backend" FORCE ) -set ( INTERP_BACKEND OFF CACHE STRING "Include INTERPRETER backend" FORCE ) +set ( INTERP_BACKEND OFF CACHE STRING "Include Interpreter backend" FORCE ) set ( JAVA_BACKEND OFF CACHE STRING "Include JAVA backend" FORCE ) +set ( JAX_BACKEND OFF CACHE STRING "Include JAX backend" FORCE ) set ( JULIA_BACKEND OFF CACHE STRING "Include Julia backend" FORCE ) set ( LLVM_BACKEND OFF CACHE STRING "Include LLVM backend" FORCE ) set ( OLDCPP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include old CPP backend" FORCE ) set ( RUST_BACKEND OFF CACHE STRING "Include Rust backend" FORCE ) -set ( SOUL_BACKEND OFF CACHE STRING "Include SOUL backend" FORCE ) +# Template is deactivated +set ( TEMPLATE_BACKEND OFF CACHE STRING "Include Rust backend" FORCE ) set ( WASM_BACKEND WASM COMPILER STATIC DYNAMIC CACHE STRING "Include WASM backend" FORCE ) diff -Nru faust-2.50.6+ds0/build/backends/most.cmake faust-2.54.9+ds0/build/backends/most.cmake --- faust-2.50.6+ds0/build/backends/most.cmake 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/build/backends/most.cmake 2022-12-17 10:41:42.000000000 +0000 @@ -7,16 +7,19 @@ # DYNAMIC embed the backend in the faust dynamic library # WASM embed the backend in the faust wasm library -set ( C_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include C backend" FORCE ) -set ( CPP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include CPP backend" FORCE ) -set ( CSHARP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include CSharp backend" FORCE ) -set ( DLANG_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include DLANG backend" FORCE ) -set ( FIR_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include FIR backend" FORCE ) +set ( C_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include C backend" FORCE ) +set ( CPP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include CPP backend" FORCE ) +set ( CMAJOR_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Cmajor backend" FORCE ) +set ( CSHARP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include CSharp backend" FORCE ) +set ( DLANG_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Dlang backend" FORCE ) +set ( FIR_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include FIR backend" FORCE ) set ( INTERP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include INTERPRETER backend" FORCE ) set ( JAVA_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include JAVA backend" FORCE ) +set ( JAX_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include JAX backend" FORCE ) set ( JULIA_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Julia backend" FORCE ) set ( LLVM_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include LLVM backend" FORCE ) set ( OLDCPP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include old CPP backend" FORCE ) set ( RUST_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Rust backend" FORCE ) -set ( SOUL_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include SOUL backend" FORCE ) +# Template is deactivated +set ( TEMPLATE_BACKEND OFF CACHE STRING "Include Template backend" FORCE ) set ( WASM_BACKEND COMPILER STATIC DYNAMIC WASM CACHE STRING "Include WASM backend" FORCE ) diff -Nru faust-2.50.6+ds0/build/backends/regular.cmake faust-2.54.9+ds0/build/backends/regular.cmake --- faust-2.50.6+ds0/build/backends/regular.cmake 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/build/backends/regular.cmake 2022-12-17 10:41:42.000000000 +0000 @@ -9,14 +9,17 @@ set ( C_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include C backend" FORCE ) set ( CPP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include CPP backend" FORCE ) +set ( CMAJOR_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Cmajor backend" FORCE ) set ( CSHARP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include CSharp backend" FORCE ) -set ( DLANG_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include DLANG backend" FORCE ) +set ( DLANG_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Dlang backend" FORCE ) set ( FIR_BACKEND OFF CACHE STRING "Include FIR backend" FORCE ) -set ( INTERP_BACKEND OFF CACHE STRING "Include INTERPRETER backend" FORCE ) +set ( INTERP_BACKEND OFF CACHE STRING "Include Interpreter backend" FORCE ) set ( JAVA_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include JAVA backend" FORCE ) +set ( JAX_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include JAX backend" FORCE ) set ( JULIA_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Julia backend" FORCE ) set ( LLVM_BACKEND OFF CACHE STRING "Include LLVM backend" FORCE ) set ( OLDCPP_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include old CPP backend" FORCE ) -set ( RUST_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include RUST backend" FORCE ) -set ( SOUL_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include SOUL backend" FORCE ) +set ( RUST_BACKEND COMPILER STATIC DYNAMIC CACHE STRING "Include Rust backend" FORCE ) +# Template is deactivated +set ( TEMPLATE_BACKEND OFF CACHE STRING "Include Template backend" FORCE ) set ( WASM_BACKEND WASM COMPILER STATIC DYNAMIC CACHE STRING "Include WASM backend" FORCE ) diff -Nru faust-2.50.6+ds0/build/CMakeLists.txt faust-2.54.9+ds0/build/CMakeLists.txt --- faust-2.50.6+ds0/build/CMakeLists.txt 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/build/CMakeLists.txt 2022-12-17 10:41:42.000000000 +0000 @@ -3,7 +3,7 @@ ####################################### # versions management -set (VERSION 2.50.6) +set (VERSION 2.54.9) macro (get_major_minor_patch version) string( REGEX REPLACE "([0-9]*)\\.([0-9]*)\\.([0-9]*)" "\\1" VERSION_MAJOR ${version} ) string( REGEX REPLACE "([0-9]*)\\.([0-9]*)\\.([0-9]*)" "\\2" VERSION_MINOR ${version} ) @@ -68,7 +68,7 @@ ${SRCDIR}/generator/julia ${SRCDIR}/generator/interpreter ${SRCDIR}/generator/rust - ${SRCDIR}/generator/soul + ${SRCDIR}/generator/cmajor ${SRCDIR}/normalize ${SRCDIR}/parallelize ${SRCDIR}/parser ${SRCDIR}/patternmatcher ${SRCDIR}/propagate ${SRCDIR}/signals ${SRCDIR}/tlib ${SRCDIR}/transform ${SRCDIR}/utils @@ -136,6 +136,7 @@ set (CMAKE_OSX_ARCHITECTURES x86_64 arm64) set (FAUST_DEFINITIONS ${FAUST_DEFINITIONS} -DLLVM_BUILD_UNIVERSAL) endif() + link_directories(/opt/local/lib) endif() elseif(WIN32 OR MSYS) if (NOT MSVC) @@ -415,7 +416,7 @@ ) # install folders -set (ARCHSRC android api AU audiokit daisy esp32 iOS juce julia soul max-msp nodejs osclib sam smartKeyboard teensy unity vcvrack webaudio) +set (ARCHSRC android api AU audiokit daisy esp32 iOS juce julia cmajor max-msp nodejs osclib sam smartKeyboard teensy unity vcvrack webaudio) foreach (dir ${ARCHSRC}) set(ARCHFOLDERS ${ARCHFOLDERS} ${ARCHDIR}/${dir}) endforeach() diff -Nru faust-2.50.6+ds0/build/faustgen/setup.cmake faust-2.54.9+ds0/build/faustgen/setup.cmake --- faust-2.50.6+ds0/build/faustgen/setup.cmake 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/build/faustgen/setup.cmake 2022-12-17 10:41:42.000000000 +0000 @@ -12,15 +12,16 @@ set ( ASMJS_BACKEND OFF ASMJS CACHE STRING "Include ASMJS backend" FORCE ) set ( C_BACKEND OFF CACHE STRING "Include C backend" FORCE ) set ( CPP_BACKEND COMPILER STATIC CACHE STRING "Include CPP backend" FORCE ) +set ( DLANG_BACKEND OFF CACHE STRING "Include Dlang backend" FORCE ) set ( FIR_BACKEND OFF CACHE STRING "Include FIR backend" FORCE ) -set ( INTERP_BACKEND OFF CACHE STRING "Include INTERPRETER backend" FORCE ) +set ( INTERP_BACKEND OFF CACHE STRING "Include Interpreter backend" FORCE ) set ( JAVA_BACKEND OFF CACHE STRING "Include JAVA backend" FORCE ) set ( JS_BACKEND OFF CACHE STRING "Include JAVASCRIPT backend" FORCE ) set ( LLVM_BACKEND COMPILER STATIC CACHE STRING "Include LLVM backend" FORCE ) set ( OLDCPP_BACKEND OFF CACHE STRING "Include old CPP backend" FORCE ) set ( RUST_BACKEND OFF CACHE STRING "Include RUST backend" FORCE ) set ( WASM_BACKEND OFF WASM CACHE STRING "Include WASM backend" FORCE ) -set ( DLANG_BACKEND OFF CACHE STRING "Include DLANG backend" FORCE ) + set ( INCLUDE_EXECUTABLE ON CACHE STRING "Include faust compiler" FORCE ) set ( INCLUDE_STATIC ON CACHE STRING "Include static faust library" FORCE ) diff -Nru faust-2.50.6+ds0/build/Makefile faust-2.54.9+ds0/build/Makefile --- faust-2.50.6+ds0/build/Makefile 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/build/Makefile 2022-12-17 10:41:42.000000000 +0000 @@ -11,7 +11,7 @@ # output directories FAUSTDIR ?= faustdir IOSDIR := iosdir -VERSION := 2.50.6 +VERSION := 2.54.9 #=============================================================== # current generator and backends @@ -19,7 +19,7 @@ BCACHE = $(FAUSTDIR)/backends.txt TCACHE = $(FAUSTDIR)/targets.txt LCACHE = $(FAUSTDIR)/libsdir.txt -ifeq ($(system), MINGW) +ifeq ($(system), MINGW) GENERATOR ?= $(shell [ -f $(CACHE) ] && (grep CMAKE_GENERATOR:INTERNAL $(CACHE) | cut -d= -f2) || echo MSYS Makefiles) NATIVEPACK = winpack else @@ -28,9 +28,9 @@ endif DESTDIR ?= -ifeq ($(system), MINGW) +ifeq ($(system), MINGW) NATIVEPACK = winpack -else ifeq ($(system), Darwin) +else ifeq ($(system), Darwin) NATIVEPACK = macpack else NATIVEPACK = linuxpack @@ -203,6 +203,8 @@ mactools: $(MAKE) -C ../tools/benchmark FAUST=$(FAUSTDIR)/bin/faust TARGETS="dynamic-faust faustbench-llvm interp-tracer" $(MAKE) -C ../tools/benchmark install PREFIX=$(FAUSTDIR) FAUST=$(FAUSTDIR)/bin/faust TARGETS="dynamic-faust faustbench-llvm interp-tracer" + $(MAKE) -C ../tools/sound2faust FAUST=$(FAUSTDIR)/bin/faust TARGETS="sound2faust sound2file" + $(MAKE) -C ../tools/sound2faust install PREFIX=$(FAUSTDIR) FAUST=$(FAUSTDIR)/bin/faust TARGETS="sound2faust sound2file" linuxpack: @echo Linux packaging not implemented. diff -Nru faust-2.50.6+ds0/build/MakeRelease.bat faust-2.54.9+ds0/build/MakeRelease.bat --- faust-2.50.6+ds0/build/MakeRelease.bat 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/build/MakeRelease.bat 2022-12-17 10:41:42.000000000 +0000 @@ -3,9 +3,9 @@ IF [%1]==[] GOTO USAGE IF NOT EXIST %1 GOTO USAGE -SET VERSION=2.50.6 +SET VERSION=2.54.9 SET BUILD=%1 -SET FAUSTGENVERSION=1.62 +SET FAUSTGENVERSION=1.63 SET FAUSTLIVE=../../faustlive echo "Building Faust version %VERSION%" diff -Nru faust-2.50.6+ds0/build/misc/llvm.cmake faust-2.54.9+ds0/build/misc/llvm.cmake --- faust-2.50.6+ds0/build/misc/llvm.cmake 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/build/misc/llvm.cmake 2022-12-17 10:41:42.000000000 +0000 @@ -20,6 +20,10 @@ if (${POS} GREATER -1) backend (CPP cpp ${TARGET}) endif() + string (FIND "${CMAJOR_BACKEND}" ${FLAG} POS) + if (${POS} GREATER -1) + backend (CMAJOR cmajor ${TARGET}) + endif() string (FIND "${CSHARP_BACKEND}" ${FLAG} POS) if (${POS} GREATER -1) backend (CSHARP csharp ${TARGET}) @@ -39,11 +43,15 @@ string (FIND "${JAVA_BACKEND}" ${FLAG} POS) if (${POS} GREATER -1) backend (JAVA java ${TARGET}) - endif() + endif() + string (FIND "${JAX_BACKEND}" ${FLAG} POS) + if (${POS} GREATER -1) + backend (JAX jax ${TARGET}) + endif() string (FIND "${JULIA_BACKEND}" ${FLAG} POS) if (${POS} GREATER -1) backend (JULIA julia ${TARGET}) - endif() + endif() string (FIND "${OLDCPP_BACKEND}" ${FLAG} POS) if (${POS} GREATER -1) backend (OCPP "" ${TARGET}) @@ -52,9 +60,9 @@ if (${POS} GREATER -1) backend (RUST rust ${TARGET}) endif() - string (FIND "${SOUL_BACKEND}" ${FLAG} POS) - if (${POS} GREATER -1) - backend (SOUL soul ${TARGET}) + string (FIND "${TEMPLATE_BACKEND}" ${FLAG} POS) + if (${POS} GREATER -1) + backend (TEMPLATE template ${TARGET}) endif() string (FIND "${WASM_BACKEND}" ${FLAG} POS) if (${POS} GREATER -1) diff -Nru faust-2.50.6+ds0/compiler/dsp_factory.hh faust-2.54.9+ds0/compiler/dsp_factory.hh --- faust-2.50.6+ds0/compiler/dsp_factory.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/dsp_factory.hh 2022-12-17 10:41:42.000000000 +0000 @@ -25,6 +25,7 @@ #include #include #include +#include #include "faust/export.h" #include "faust/gui/CInterface.h" @@ -36,6 +37,8 @@ #define COMPILATION_OPTIONS_KEY "compile_options" #define COMPILATION_OPTIONS "declare compile_options " +extern std::vector gWarningMessages; + /* In order to better separate compilation and execution for dynamic backends (LLVM, Interpreter, WebAssembly). A dsp_factory_base* object will either be generated by the compiler from a dsp, @@ -60,7 +63,9 @@ virtual void setDSPCode(const std::string& code) = 0; virtual std::string getCompileOptions() = 0; - + + virtual std::vector getWarningMessages() = 0; + virtual dsp* createDSPInstance(dsp_factory* factory) = 0; virtual void setMemoryManager(dsp_memory_manager* manager) = 0; @@ -79,9 +84,10 @@ class dsp_factory_imp : public dsp_factory_base { protected: - std::string fName; - std::string fSHAKey; - std::string fExpandedDSP; + std::string fName; + std::string fSHAKey; + std::string fExpandedDSP; + dsp_memory_manager* fManager; public: @@ -116,7 +122,9 @@ void setDSPCode(const std::string& code) { fExpandedDSP = code; } virtual std::string getCompileOptions() { return ""; }; - + + virtual std::vector getWarningMessages() { return gWarningMessages; } + virtual dsp* createDSPInstance(dsp_factory* factory) { faustassert(false); @@ -178,16 +186,20 @@ typedef CTree* Signal; typedef std::vector tvec; -dsp_factory_base* createFactory(const char* name, const char* input, +dsp_factory_base* createFactory(const std::string& name_app, + const std::string& dsp_content, int argc, const char* argv[], std::string& error_msg, bool generate); -dsp_factory_base* createFactory(const char* name, tvec signals, +dsp_factory_base* createFactory(const std::string& name_app, + tvec signals, int argc, const char* argv[], std::string& error_msg); -std::string expandDSP(int argc, const char* argv[], const char* name, - const char* input, std::string& sha_key, +std::string expandDSP(const std::string& name_app, + const std::string& dsp_content, + int argc, const char* argv[], + std::string& sha_key, std::string& error_msg); #endif diff -Nru faust-2.50.6+ds0/compiler/errors/errormsg.cpp faust-2.54.9+ds0/compiler/errors/errormsg.cpp --- faust-2.50.6+ds0/compiler/errors/errormsg.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/errors/errormsg.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -89,14 +89,14 @@ { stringstream error; error << filename << " : " << linenum << " : WARNING : " << msg << " : " << boxpp(exp) << endl; - gGlobal->gErrorMsg = error.str(); + gGlobal->gErrorMessage = error.str(); } void evalremark(const char* filename, int linenum, const char* msg, Tree exp) { stringstream error; error << filename << " : " << linenum << " : REMARK : " << msg << " : " << boxpp(exp) << endl; - gGlobal->gErrorMsg = error.str(); + gGlobal->gErrorMessage = error.str(); } void setDefProp(Tree sym, const char* filename, int lineno) diff -Nru faust-2.50.6+ds0/compiler/evaluate/loopDetector.hh faust-2.54.9+ds0/compiler/evaluate/loopDetector.hh --- faust-2.50.6+ds0/compiler/evaluate/loopDetector.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/evaluate/loopDetector.hh 2022-12-17 10:41:42.000000000 +0000 @@ -48,7 +48,7 @@ bool detect(Tree t); }; -#define MAX_STACK_SIZE 524288 * 128 +#define MAX_STACK_SIZE 1024 * 1024 * 16 // 16 MO #define STACK_FRAME 65536 * 4 class stackOverflowDetector { diff -Nru faust-2.50.6+ds0/compiler/extended/powprim.hh faust-2.54.9+ds0/compiler/extended/powprim.hh --- faust-2.50.6+ds0/compiler/extended/powprim.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/extended/powprim.hh 2022-12-17 10:41:42.000000000 +0000 @@ -155,7 +155,7 @@ // Expand the pow depending of the exposant argument BlockInst* block = InstBuilder::genBlockInst(); string faust_power_name = container->getFaustPowerName() + to_string(pow_arg) + ((rtype == Typed::kInt32) ? "_i" : "_f"); - + Names named_args; named_args.push_back(InstBuilder::genNamedTyped("value", InstBuilder::genBasicTyped(t0))); diff -Nru faust-2.50.6+ds0/compiler/generator/c/c_code_container.cpp faust-2.54.9+ds0/compiler/generator/c/c_code_container.cpp --- faust-2.50.6+ds0/compiler/generator/c/c_code_container.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/c/c_code_container.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -539,34 +539,34 @@ tab(n, *fOut); tab(n, *fOut); - *fOut << "void instanceResetUserInterface" << fKlassName << "(" << fKlassName << "* dsp) {"; + *fOut << "void instanceConstants" << fKlassName << "(" << fKlassName << "* dsp, int sample_rate) {"; { tab(n + 1, *fOut); fCodeProducer->Tab(n + 1); - generateResetUserInterface(fCodeProducer); + // Rename 'sig' in 'dsp', remove 'dsp' allocation, inline subcontainers 'instanceInit' and 'fill' function call + inlineSubcontainersFunCalls(fInitInstructions)->accept(fCodeProducer); } back(1, *fOut); *fOut << "}"; tab(n, *fOut); tab(n, *fOut); - *fOut << "void instanceClear" << fKlassName << "(" << fKlassName << "* dsp) {"; + *fOut << "void instanceResetUserInterface" << fKlassName << "(" << fKlassName << "* dsp) {"; { tab(n + 1, *fOut); fCodeProducer->Tab(n + 1); - generateClear(fCodeProducer); + generateResetUserInterface(fCodeProducer); } back(1, *fOut); *fOut << "}"; tab(n, *fOut); tab(n, *fOut); - *fOut << "void instanceConstants" << fKlassName << "(" << fKlassName << "* dsp, int sample_rate) {"; + *fOut << "void instanceClear" << fKlassName << "(" << fKlassName << "* dsp) {"; { tab(n + 1, *fOut); fCodeProducer->Tab(n + 1); - // Rename 'sig' in 'dsp', remove 'dsp' allocation, inline subcontainers 'instanceInit' and 'fill' function call - inlineSubcontainersFunCalls(fInitInstructions)->accept(fCodeProducer); + generateClear(fCodeProducer); } back(1, *fOut); *fOut << "}"; @@ -787,42 +787,42 @@ } back(1, *fOut); *fOut << "}"; - tab(n, *fOut); + tab(n, *fOut); - *fOut << "void instanceResetUserInterface" << fKlassName << "(" << fKlassName << "* dsp) {"; + *fOut << "void instanceConstants" << fKlassName << "(" << fKlassName << "* dsp, int sample_rate, " << subst("int* iZone, $0* fZone) {", ifloat()); { tab(n + 1, *fOut); fCodeProducer->Tab(n + 1); - generateResetUserInterface(fCodeProducer); + // Rename 'sig' in 'dsp', remove 'dsp' allocation, inline subcontainers 'instanceInit' and 'fill' function call + inlineSubcontainersFunCalls(fInitInstructions)->accept(fCodeProducer); } back(1, *fOut); *fOut << "}"; - tab(n, *fOut); + tab(n, *fOut); - *fOut << "void instanceClear" << fKlassName << "(" << fKlassName << "* dsp, " << subst("int* iZone, $0* fZone) {", ifloat()); + *fOut << "void instanceResetUserInterface" << fKlassName << "(" << fKlassName << "* dsp) {"; { tab(n + 1, *fOut); fCodeProducer->Tab(n + 1); - generateClear(fCodeProducer); + generateResetUserInterface(fCodeProducer); } back(1, *fOut); *fOut << "}"; - tab(n, *fOut); + tab(n, *fOut); - *fOut << "void instanceConstants" << fKlassName << "(" << fKlassName << "* dsp, int sample_rate, " << subst("int* iZone, $0* fZone) {", ifloat()); + *fOut << "void instanceClear" << fKlassName << "(" << fKlassName << "* dsp, " << subst("int* iZone, $0* fZone) {", ifloat()); { tab(n + 1, *fOut); fCodeProducer->Tab(n + 1); - // Rename 'sig' in 'dsp', remove 'dsp' allocation, inline subcontainers 'instanceInit' and 'fill' function call - inlineSubcontainersFunCalls(fInitInstructions)->accept(fCodeProducer); + generateClear(fCodeProducer); } back(1, *fOut); *fOut << "}"; - tab(n, *fOut); + tab(n, *fOut); *fOut << "void instanceInit" << fKlassName << "(" << fKlassName << "* dsp, int sample_rate, " << subst("int* iZone, $0* fZone) {", ifloat()); // staticInit has to be called for each instance since the tables are actually not shared between instances @@ -836,8 +836,8 @@ *fOut << "instanceClear" << fKlassName << "(dsp, iZone, fZone);"; tab(n, *fOut); *fOut << "}"; - tab(n, *fOut); + tab(n, *fOut); *fOut << "void init" << fKlassName << "(" << fKlassName << "* dsp, int sample_rate, " << subst("int* iZone, $0* fZone) {", ifloat()); tab(n + 1, *fOut); @@ -856,8 +856,8 @@ back(1, *fOut); *fOut << "}"; } - tab(n, *fOut); + tab(n, *fOut); *fOut << "void control" << fKlassName << "(" << fKlassName << "* dsp, " << subst("int* RESTRICT iControl, $0* RESTRICT fControl, int* RESTRICT iZone, $0* RESTRICT fZone) {", ifloat()); tab(n + 1, *fOut); @@ -1063,28 +1063,6 @@ tab(n, *fOut); tab(n, *fOut); - *fOut << "void instanceResetUserInterface" << fKlassName << "(" << fKlassName << "* dsp) {"; - { - tab(n + 1, *fOut); - fCodeProducer->Tab(n + 1); - generateResetUserInterface(fCodeProducer); - } - back(1, *fOut); - *fOut << "}"; - - tab(n, *fOut); - tab(n, *fOut); - *fOut << "void instanceClear" << fKlassName << "(" << fKlassName << "* dsp, " << subst("int* iZone, $0* fZone) {", ifloat()); - { - tab(n + 1, *fOut); - fCodeProducer->Tab(n + 1); - generateClear(fCodeProducer); - } - back(1, *fOut); - *fOut << "}"; - - tab(n, *fOut); - tab(n, *fOut); *fOut << "void instanceConstants" << fKlassName << "(" << fKlassName << "* dsp, int sample_rate, " << subst("int* iZone, $0* fZone) {", ifloat()); { tab(n + 1, *fOut); @@ -1094,8 +1072,8 @@ } back(1, *fOut); *fOut << "}"; - tab(n, *fOut); + tab(n, *fOut); *fOut << "void instanceConstantsFromMem" << fKlassName << "(" << fKlassName << "* dsp, int sample_rate, " << subst("int* iZone, $0* fZone) {", ifloat()); tab(n + 1, *fOut); @@ -1107,8 +1085,8 @@ copy_from_mem.getCode(block1)->accept(&visitor1); back(1, *fOut); *fOut << "}"; - tab(n, *fOut); + tab(n, *fOut); *fOut << "void instanceConstantsToMem" << fKlassName << "(" << fKlassName << "* dsp, int sample_rate, " << subst("int* iZone, $0* fZone) {", ifloat()); tab(n + 1, *fOut); @@ -1120,8 +1098,30 @@ copy_to_mem.getCode(block2)->accept(&visitor); back(1, *fOut); *fOut << "}"; + tab(n, *fOut); + + tab(n, *fOut); + *fOut << "void instanceResetUserInterface" << fKlassName << "(" << fKlassName << "* dsp) {"; + { + tab(n + 1, *fOut); + fCodeProducer->Tab(n + 1); + generateResetUserInterface(fCodeProducer); + } + back(1, *fOut); + *fOut << "}"; + tab(n, *fOut); tab(n, *fOut); + *fOut << "void instanceClear" << fKlassName << "(" << fKlassName << "* dsp, " << subst("int* iZone, $0* fZone) {", ifloat()); + { + tab(n + 1, *fOut); + fCodeProducer->Tab(n + 1); + generateClear(fCodeProducer); + } + back(1, *fOut); + *fOut << "}"; + tab(n, *fOut); + tab(n, *fOut); *fOut << "void instanceInit" << fKlassName << "(" << fKlassName << "* dsp, int sample_rate, " << subst("int* iZone, $0* fZone) {", ifloat()); // staticInit has to be called for each instance since the tables are actually not shared between instances @@ -1137,8 +1137,8 @@ *fOut << "instanceClear" << fKlassName << "(dsp, iZone, fZone);"; tab(n, *fOut); *fOut << "}"; - tab(n, *fOut); + tab(n, *fOut); *fOut << "void init" << fKlassName << "(" << fKlassName << "* dsp, int sample_rate, " << subst("int* iZone, $0* fZone) {", ifloat()); tab(n + 1, *fOut); @@ -1157,8 +1157,8 @@ back(1, *fOut); *fOut << "}"; } - tab(n, *fOut); + tab(n, *fOut); *fOut << "void control" << fKlassName << "(" << fKlassName << "* dsp, " << subst("int* RESTRICT iControl, $0* RESTRICT fControl, int* RESTRICT iZone, $0* RESTRICT fZone) {", ifloat()); tab(n + 1, *fOut); diff -Nru faust-2.50.6+ds0/compiler/generator/cmajor/cmajor_code_container.cpp faust-2.54.9+ds0/compiler/generator/cmajor/cmajor_code_container.cpp --- faust-2.50.6+ds0/compiler/generator/cmajor/cmajor_code_container.cpp 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/cmajor/cmajor_code_container.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,478 @@ +/************************************************************************ + ************************************************************************ + FAUST compiler + Copyright (C) 2003-2019 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., 675 Mass Ave, Cambridge, MA 02139, USA. + ************************************************************************ + ************************************************************************/ + +#include "cmajor_code_container.hh" +#include "global.hh" + +using namespace std; + +/* + Cmajor backend description: + + - sub-containers are compiled as 'struct' with associated functions + - classInit is a Processor method for now (waiting for the Cmajor external model to be ready) + - 'faustpower' function fallbacks to regular 'pow' (see powprim.h) + - the 'fillXXX' function needs to generate the actual size of the table argument type. This is done using the + TableSizeVisitor class. + - bargraphs use 'output event' type and are outputting values at 50 Hz. The code is conditionally generated. +*/ + +dsp_factory_base* CmajorCodeContainer::produceFactory() +{ + return new text_dsp_factory_aux( + fKlassName, "", "", ((static_cast(fOut)) ? static_cast(fOut)->str() : ""), ""); +} + +CodeContainer* CmajorCodeContainer::createScalarContainer(const string& name, int sub_container_type) +{ + return new CmajorScalarCodeContainer(name, 0, 1, sub_container_type, fOut); +} + +CodeContainer* CmajorCodeContainer::createContainer(const string& name, int numInputs, int numOutputs, ostream* dst) +{ + if (isdigit(name[0])) { + stringstream error; + error << "ERROR : processor '" << name << "' cannot start with a digit\n"; + throw faustexception(error.str()); + } + + CodeContainer* container; + + if (gGlobal->gOpenMPSwitch) { + throw faustexception("ERROR : OpenMP not supported for Cmajor\n"); + } else if (gGlobal->gSchedulerSwitch) { + throw faustexception("ERROR : Scheduler not supported for Cmajor\n"); + } else if (gGlobal->gVectorSwitch) { + throw faustexception("ERROR : Vector mode not supported for Cmajor\n"); + // container = new CmajorVectorCodeContainer(name, numInputs, numOutputs, dst); + } else { + container = new CmajorScalarCodeContainer(name, numInputs, numOutputs, kInt, dst); + } + + return container; +} + +void CmajorCodeContainer::produceInternal() +{ + int n = 0; + CmajorSubContainerInstVisitor struct_visitor(fOut); + + // Global declarations + generateGlobalDeclarations(&struct_visitor); + + tab(n + 1, *fOut); + *fOut << "struct " << fKlassName; + tab(n + 1, *fOut); + *fOut << "{"; + tab(n + 2, *fOut); + + // Fields + struct_visitor.Tab(n + 2); + generateDeclarations(&struct_visitor); + + back(1, *fOut); + *fOut << "}" << endl; + + // Inits + tab(n + 1, *fOut); + *fOut << "void instanceInit" << fKlassName << " (" << fKlassName << "& this, int sample_rate)"; + tab(n + 1, *fOut); + *fOut << "{"; + tab(n + 2, *fOut); + struct_visitor.Tab(n + 2); + generateInit(&struct_visitor); + generateResetUserInterface(&struct_visitor); + generateClear(&struct_visitor); + back(1, *fOut); + *fOut << "}"; + + // Fill + string counter = "count"; + + // Retrieves the table size kept in gTableSizeVisitor to generate the correct table type + string fun_name = "fill" + fKlassName; + // We possibly have to generate several versions of the function with a different table size + for (const auto& it : gGlobal->gTableSizeVisitor->fSizeTable) { + string fun_name_aux = it.first; + int table_size = it.second; + if (startWith(fun_name_aux, fun_name)) { + tab(n + 1, *fOut); + if (fSubContainerType == kInt) { + tab(n + 1, *fOut); + *fOut << "void " << fun_name_aux << " (" << fKlassName << "& this, " + << subst("int $0, int[" + to_string(table_size) + "]& " + fTableName + ")", counter); + tab(n + 1, *fOut); + *fOut << "{"; + } else { + tab(n + 1, *fOut); + *fOut << "void " << fun_name_aux << " (" << fKlassName << "& this, " + << subst("int $0, $1[" + to_string(table_size) + "]& " + fTableName + ")", counter, + struct_visitor.getTypeManager()->fTypeDirectTable[itfloat()]); + tab(n + 1, *fOut); + *fOut << "{"; + } + tab(n + 2, *fOut); + struct_visitor.Tab(n + 2); + generateComputeBlock(&struct_visitor); + ForLoopInst* loop = fCurLoop->generateScalarLoop(counter); + loop->accept(&struct_visitor); + back(1, *fOut); + *fOut << "}"; + } + } + + tab(n + 1, *fOut); + *fOut << fKlassName << " new" << fKlassName << "() { " << fKlassName << " obj; return obj; }"; + tab(n + 1, *fOut); + *fOut << "void delete" << fKlassName << " (" << fKlassName << "& this) {}"; + tab(n + 1, *fOut); +} + +void CmajorCodeContainer::produceInit(int tabs) +{ + tab(tabs, *fOut); + *fOut << "void init()"; + tab(tabs, *fOut); + *fOut << "{"; + tab(tabs + 1, *fOut); + *fOut << "let sample_rate = int(processor.frequency);"; + tab(tabs + 1, *fOut); + if (fUIVisitor.fHasBargraph) { + *fOut << "fControlSlice = int (processor.frequency) / 50;"; + tab(tabs + 1, *fOut); + } + *fOut << "// classInit is not called here since the tables are actually not shared between instances"; + tab(tabs + 1, *fOut); + *fOut << "instanceInit (sample_rate);"; + tab(tabs, *fOut); + *fOut << "}"; + tab(tabs, *fOut); + + tab(tabs, *fOut); + *fOut << "void instanceInit (int sample_rate)"; + tab(tabs, *fOut); + *fOut << "{"; + tab(tabs + 1, *fOut); + *fOut << "// classInit has to be called for each instance since the tables are actually not shared between instances"; + tab(tabs + 1, *fOut); + *fOut << "classInit (sample_rate);"; + tab(tabs + 1, *fOut); + *fOut << "instanceConstants (sample_rate);"; + tab(tabs + 1, *fOut); + *fOut << "instanceResetUserInterface();"; + tab(tabs + 1, *fOut); + *fOut << "instanceClear();"; + tab(tabs, *fOut); + *fOut << "}"; + tab(tabs, *fOut); +} + +void CmajorCodeContainer::produceClass() +{ + int n = 0; + + // Look for the "fillXXX" function + generateStaticInit(gGlobal->gTableSizeVisitor); + generateInit(gGlobal->gTableSizeVisitor); + + // Processor generation + tab(n, *fOut); + *fOut << "processor " << fKlassName; + tab(n, *fOut); + *fOut << "{"; + + // Fields + tab(n + 1, *fOut); + fCodeProducer.Tab(n + 1); + + if (gGlobal->gOutputLang == "cmajor-dsp") { + string json = generateJSONAux(); + *fOut << "// Event used to call additional methods"; + tab(n + 1, *fOut); + *fOut << "input event int eventbuildUserInterface [[json: \"" << flattenJSON(json) << "\"]];"; + tab(n + 1, *fOut); + *fOut << "input event int eventclassInit;"; + tab(n + 1, *fOut); + *fOut << "input event int eventinstanceConstants;"; + tab(n + 1, *fOut); + *fOut << "input event int eventinstanceResetUserInterface;"; + tab(n + 1, *fOut); + *fOut << "input event int eventinstanceClear;"; + tab(n + 1, *fOut); + tab(n + 1, *fOut); + } + + generateUserInterface(&fUIVisitor); + *fOut << fUIVisitor.fOut.str(); + generateDeclarations(&fCodeProducer); + + // Control + *fOut << "bool fUpdated;"; + tab(n + 1, *fOut); + if (fUIVisitor.fHasBargraph) { + *fOut << "int fControlSlice;"; + tab(n + 1, *fOut); + } + + // For control computation + if (fInt32ControlNum > 0) { + *fOut << "int32[" << fInt32ControlNum << "] iControl;"; + tab(n + 1, *fOut); + } + if (fRealControlNum > 0) { + *fOut << fCodeProducer.getTypeManager()->fTypeDirectTable[itfloat()] << "[" << fRealControlNum << "] fControl;"; + } + + // Global declarations + if (fGlobalDeclarationInstructions->fCode.size() > 0) { + tab(n + 1, *fOut); + fCodeProducer.Tab(n + 1); + generateGlobalDeclarations(&fCodeProducer); + } + + // UI + if (fUserInterfaceInstructions->fCode.size() > 0) { + tab(n + 1, *fOut); + fCodeProducer.Tab(n + 1); + generateUserInterface(&fCodeProducer); + } + + /* + // Debug version + if (gGlobal->gOutputLang == "cmajor-dsp") { + *fOut << "// Event handler used to call additional methods"; + tab(n + 1, *fOut); + *fOut << "event eventbuildUserInterface (int dummy) { console << \"eventbuildUserInterface\n\"; }"; + tab(n + 1, *fOut); + *fOut << "event eventclassInit (int sample_rate) { console << \"eventclassInit\n\"; classInit(sample_rate); }"; + tab(n + 1, *fOut); + *fOut << "event eventinstanceConstants (int sample_rate) { console << \"eventinstanceConstants\n\"; instanceConstants(sample_rate); }"; + tab(n + 1, *fOut); + *fOut << "event eventinstanceResetUserInterface (int dummy) { console << \"eventinstanceResetUserInterface\n\"; instanceResetUserInterface(); }"; + tab(n + 1, *fOut); + *fOut << "event eventinstanceClear (int dummy) { console << \"eventinstanceClear\n\"; instanceClear(); }"; + tab(n + 1, *fOut); + tab(n + 1, *fOut); + } + */ + + if (gGlobal->gOutputLang == "cmajor-dsp") { + *fOut << "// Event handler used to call additional methods"; + tab(n + 1, *fOut); + *fOut << "event eventbuildUserInterface (int dummy) {}"; + tab(n + 1, *fOut); + *fOut << "event eventclassInit (int sample_rate) { classInit(sample_rate); }"; + tab(n + 1, *fOut); + *fOut << "event eventinstanceConstants (int sample_rate) { instanceConstants(sample_rate); }"; + tab(n + 1, *fOut); + *fOut << "event eventinstanceResetUserInterface (int dummy) { instanceResetUserInterface(); }"; + tab(n + 1, *fOut); + *fOut << "event eventinstanceClear (int dummy) { instanceClear(); }"; + tab(n + 1, *fOut); + tab(n + 1, *fOut); + } + + // Generate gub containers + generateSubContainers(); + + // Missing math functions + tab(n + 1, *fOut); + if (gGlobal->gFloatSize == 1) { + *fOut << "float32 copysign(float32 x, float32 y) { return abs(x) * ((y < 0.0f) ? -1.0f : 1.0f); }"; + } else if (gGlobal->gFloatSize == 2) { + *fOut << "float64 copysign(float64 x, float64 y) { return abs(x) * ((y < 0.0) ? -1.0 : 1.0); }"; + } + tab(n + 1, *fOut); + + // inputs/outputs + tab(n + 1, *fOut); + *fOut << "int getNumInputs() { return " << fNumInputs << "; }"; + tab(n + 1, *fOut); + tab(n + 1, *fOut); + *fOut << "int getNumOuputs() { return " << fNumOutputs << "; }"; + tab(n + 1, *fOut); + + tab(n + 1, *fOut); + *fOut << "void classInit (int sample_rate)"; + tab(n + 1, *fOut); + *fOut << "{"; + tab(n + 2, *fOut); + fCodeProducer.Tab(n + 2); + // Rename the 'fillXXX' function with the proper table size + { + TableSizeCloneVisitor fill_funcall; + BlockInst* block1 = fill_funcall.getCode(fStaticInitInstructions); + block1->accept(&fCodeProducer); + BlockInst* block2 = fill_funcall.getCode(fPostStaticInitInstructions); + block2->accept(&fCodeProducer); + } + back(1, *fOut); + *fOut << "}"; + tab(n + 1, *fOut); + + tab(n + 1, *fOut); + *fOut << "void instanceConstants (int sample_rate)"; + tab(n + 1, *fOut); + *fOut << "{"; + tab(n + 2, *fOut); + fCodeProducer.Tab(n + 2); + // Rename the 'fillXXX' function with the proper table size + { + TableSizeCloneVisitor fill_funcall; + BlockInst* block1 = fill_funcall.getCode(fInitInstructions); + block1->accept(&fCodeProducer); + BlockInst* block2 = fill_funcall.getCode(fPostInitInstructions); + block2->accept(&fCodeProducer); + } + back(1, *fOut); + *fOut << "}"; + tab(n + 1, *fOut); + + tab(n + 1, *fOut); + *fOut << "void instanceResetUserInterface()"; + tab(n + 1, *fOut); + *fOut << "{"; + tab(n + 2, *fOut); + + // Control + *fOut << "fUpdated = true;"; + tab(n + 2, *fOut); + + fCodeProducer.Tab(n + 2); + generateResetUserInterface(&fCodeProducer); + back(1, *fOut); + *fOut << "}"; + tab(n + 1, *fOut); + + tab(n + 1, *fOut); + *fOut << "void instanceClear()"; + tab(n + 1, *fOut); + *fOut << "{"; + tab(n + 2, *fOut); + fCodeProducer.Tab(n + 2); + generateClear(&fCodeProducer); + back(1, *fOut); + *fOut << "}"; + tab(n + 1, *fOut); + + // Init + produceInit(n + 1); + + // Control + tab(n + 1, *fOut); + *fOut << "void control()"; + tab(n + 1, *fOut); + *fOut << "{"; + tab(n + 2, *fOut); + // Debug code + //*fOut << "console << \"control\\n\";"; + fCodeProducer.Tab(n + 2); + // Generates local variables declaration and setup + generateComputeBlock(&fCodeProducer); + back(1, *fOut); + *fOut << "}" << endl; + + // Compute + generateCompute(n + 1); + *fOut << "}" << endl; +} + +void CmajorScalarCodeContainer::generateCompute(int n) +{ + tab(n, *fOut); + *fOut << "void main()"; + tab(n, *fOut); + *fOut << "{"; + tab(n + 1, *fOut); + *fOut << "// DSP loop running forever..."; + tab(n + 1, *fOut); + *fOut << "loop"; + tab(n + 1, *fOut); + *fOut << "{"; + tab(n + 2, *fOut); + *fOut << "if (fUpdated) { fUpdated = false; control(); }"; + tab(n + 2, *fOut); + tab(n + 2, *fOut); + + // Generates one sample computation + fCodeProducer.Tab(n + 2); + *fOut << "// Computes one sample"; + tab(n + 2, *fOut); + BlockInst* block = fCurLoop->generateOneSample(); + block->accept(&fCodeProducer); + + // Currently for soundfile management + generatePostComputeBlock(&fCodeProducer); + + tab(n + 2, *fOut); + if (fUIVisitor.fHasBargraph) { + *fOut << "// Updates fControlSlice once per sample"; + tab(n + 2, *fOut); + *fOut << "if (fControlSlice-- == 0) { fControlSlice = int (processor.frequency) / 50; }"; + tab(n + 2, *fOut); + } + *fOut << "// Moves all streams forward by one 'tick'"; + tab(n + 2, *fOut); + *fOut << "advance();"; + tab(n + 1, *fOut); + *fOut << "}"; + + tab(n, *fOut); + *fOut << "}" << endl; +} + +void CmajorVectorCodeContainer::generateCompute(int n) +{ + tab(n, *fOut); + *fOut << "void main()"; + tab(n, *fOut); + *fOut << "{"; + tab(n + 1, *fOut); + *fOut << "// 'init' called once before starting the DSP loop"; + tab(n + 1, *fOut); + *fOut << "init (int(processor.frequency));"; + + tab(n + 1, *fOut); + tab(n + 1, *fOut); + *fOut << "// DSP loop running forever..."; + tab(n + 1, *fOut); + *fOut << "loop"; + *fOut << "{"; + tab(n + 2, *fOut); + + tab(n + 2, *fOut); + *fOut << "if (fUpdated) { fUpdated = false; control(); }"; + tab(n + 2, *fOut); + tab(n + 2, *fOut); + + // TODO + fCodeProducer.Tab(n + 2); + + tab(n + 2, *fOut); + *fOut << "// Move all streams forward by one 'tick'"; + tab(n + 2, *fOut); + *fOut << "advance();"; + tab(n + 1, *fOut); + *fOut << "}"; + + tab(n, *fOut); + *fOut << "}" << endl << endl; +} diff -Nru faust-2.50.6+ds0/compiler/generator/cmajor/cmajor_code_container.hh faust-2.54.9+ds0/compiler/generator/cmajor/cmajor_code_container.hh --- faust-2.50.6+ds0/compiler/generator/cmajor/cmajor_code_container.hh 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/cmajor/cmajor_code_container.hh 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,133 @@ +/************************************************************************ + ************************************************************************ + FAUST compiler + Copyright (C) 2003-2019 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., 675 Mass Ave, Cambridge, MA 02139, USA. + ************************************************************************ + ************************************************************************/ + +#ifndef _CMAJ_CODE_CONTAINER_H +#define _CMAJ_CODE_CONTAINER_H + +#include "code_container.hh" +#include "omp_code_container.hh" +#include "cmajor_instructions.hh" +#include "vec_code_container.hh" +#include "wss_code_container.hh" + +#ifdef WIN32 +#pragma warning(disable : 4250) +#endif + +// Look for the "fillXXX" function call and keep the size of the third 'table' argument +struct TableSizeVisitor : public DispatchVisitor { + map fSizeTable; + + virtual void visit(FunCallInst* inst) + { + if (startWith(inst->fName, "fill")) { + ValuesIt it = inst->fArgs.begin(); + it++; + Int32NumInst* size = dynamic_cast(*it); + faustassert(size); + it++; + LoadVarInst* table = dynamic_cast(*it); + faustassert(table); + fSizeTable[inst->fName + "_" + to_string(size->fNum)] = size->fNum; + } + } +}; + +// Look for the "fillXXX" function call and rename it +struct TableSizeCloneVisitor : public BasicCloneVisitor { + virtual ValueInst* visit(FunCallInst* inst) + { + if (startWith(inst->fName, "fill")) { + ValuesIt it = inst->fArgs.begin(); + it++; + Int32NumInst* size = dynamic_cast(*it); + faustassert(size); + it++; + LoadVarInst* table = dynamic_cast(*it); + faustassert(table); + Values cloned_args; + for (const auto& it1 : inst->fArgs) { + cloned_args.push_back(it1->clone(this)); + } + return new FunCallInst(inst->fName + "_" + to_string(size->fNum), cloned_args, inst->fMethod); + } else { + return BasicCloneVisitor::visit(inst); + } + } + +}; + +class CmajorCodeContainer : public virtual CodeContainer { + protected: + CmajorInstVisitor fCodeProducer; + CmajorInstUIVisitor fUIVisitor; + std::ostream* fOut; + + void produceInit(int tabs); + + virtual void printHeader() { CodeContainer::printHeader(*fOut); } + + protected: + CmajorCodeContainer(const string& name, int numInputs, int numOutputs, ostream* out) : fCodeProducer(out), fOut(out) + { + initialize(numInputs, numOutputs); + fKlassName = name; + + if (!gGlobal->gTableSizeVisitor) { + gGlobal->gTableSizeVisitor = new TableSizeVisitor(); + } + } + + CodeContainer* createScalarContainer(const string& name, int sub_container_type); + void produceInternal(); + void produceClass(); + virtual void generateCompute(int tab) = 0; + + virtual dsp_factory_base* produceFactory(); + + public: + static CodeContainer* createContainer(const string& name, int numInputs, int numOutputs, ostream* dst); +}; + +class CmajorScalarCodeContainer : public CmajorCodeContainer { + private: + public: + CmajorScalarCodeContainer(const string& name, int numInputs, int numOutputs, int sub_container_type, ostream* dst) + : CmajorCodeContainer(name, numInputs, numOutputs, dst) + { + fSubContainerType = sub_container_type; + } + + void generateCompute(int tab); +}; + +class CmajorVectorCodeContainer : public VectorCodeContainer, public CmajorCodeContainer { + private: + public: + CmajorVectorCodeContainer(const string& name, int numInputs, int numOutputs, ostream* dst) + : VectorCodeContainer(numInputs, numOutputs), CmajorCodeContainer(name, numInputs, numOutputs, dst) + { + } + + void generateCompute(int tab); +}; + +#endif diff -Nru faust-2.50.6+ds0/compiler/generator/cmajor/cmajor_instructions.hh faust-2.54.9+ds0/compiler/generator/cmajor/cmajor_instructions.hh --- faust-2.50.6+ds0/compiler/generator/cmajor/cmajor_instructions.hh 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/cmajor/cmajor_instructions.hh 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,632 @@ +/************************************************************************ + ************************************************************************ + FAUST compiler + Copyright (C) 2003-2019 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., 675 Mass Ave, Cambridge, MA 02139, USA. + ************************************************************************ + ************************************************************************/ + +#ifndef _CMAJ_INSTRUCTIONS_H +#define _CMAJ_INSTRUCTIONS_H + +#include +#include +#include +#include +#include + +#include "text_instructions.hh" +#include "faust/gui/PathBuilder.h" + +using namespace std; + +static vector gReplace = {' ', '(', ')', '\\', '.', '-'}; + +struct CmajorInstUIVisitor : public DispatchVisitor, public PathBuilder { + std::stringstream fOut; + CmajorStringTypeManager fTypeManager; + int fTab; + bool fHasBargraph; // Whether the DSP code has some Bargraphs + + std::vector > fMetaAux; + + using DispatchVisitor::visit; + + CmajorInstUIVisitor(int tab = 1) : fTypeManager(xfloat(), "*"), fTab(tab), fHasBargraph(false) {} + + void addMeta() + { + if (fMetaAux.size() > 0) { + for (size_t i = 0; i < fMetaAux.size(); i++) { + if (!std::isdigit(fMetaAux[i].first[0])) { + fOut << ", " << "meta_" + gGlobal->getFreshID(fMetaAux[i].first) << ": " << quote(fMetaAux[i].second); + } + } + } + fMetaAux.clear(); + } + + std::string getCmajorMetadata() + { + if (fMetaAux.size() > 0) { + for (size_t i = 0; i < fMetaAux.size(); i++) { + if (fMetaAux[i].first == "cmajor") return fMetaAux[i].second; + } + } + return ""; + } + + virtual void visit(AddMetaDeclareInst* inst) + { + fMetaAux.push_back(std::make_pair(inst->fKey, inst->fValue)); + } + + virtual void visit(AddButtonInst* inst) + { + if (gGlobal->gOutputLang == "cmajor-poly") { + fOut << "input event " << fTypeManager.fTypeDirectTable[itfloat()] + << " event_" << replaceCharList(inst->fLabel, gReplace, '_') + << " [[ name: " << quote(inst->fLabel) + << ", group: " << quote(buildPath(inst->fLabel)); + if (inst->fType != AddButtonInst::kDefaultButton) { + fOut << ", latching"; + } + fOut << ", text: \"off|on\"" + << ", boolean"; + addMeta(); + fOut << " ]];"; + } else if (gGlobal->gOutputLang == "cmajor-hybrid") { + string cmajor_meta = getCmajorMetadata(); + fOut << "input event " << fTypeManager.fTypeDirectTable[itfloat()] + << " " << ((cmajor_meta != "") ? cmajor_meta : replaceCharList(inst->fLabel, gReplace, '_')) + << " [[ name: " << quote(inst->fLabel) + << ", group: " << quote(buildPath(inst->fLabel)); + if (inst->fType != AddButtonInst::kDefaultButton) { + fOut << ", latching"; + } + fOut << ", text: \"off|on\"" + << ", boolean"; + addMeta(); + fOut << " ]];"; + } else { + fOut << "input event " << fTypeManager.fTypeDirectTable[itfloat()] + << " event" << inst->fZone + << " [[ name: " << quote(inst->fLabel) + << ", group: " << quote(buildPath(inst->fLabel)); + if (inst->fType != AddButtonInst::kDefaultButton) { + fOut << ", latching"; + } + fOut << ", text: \"off|on\"" + << ", boolean"; + addMeta(); + fOut << " ]];"; + } + tab(fTab, fOut); + } + + virtual void visit(AddSliderInst* inst) + { + if (gGlobal->gOutputLang == "cmajor-poly") { + fOut << "input event " << fTypeManager.fTypeDirectTable[itfloat()] + << " event_" << replaceCharList(inst->fLabel, gReplace, '_') + << " [[ name: " << quote(inst->fLabel) + << ", group: " << quote(buildPath(inst->fLabel)) + << ", min: " << checkReal(inst->fMin) + << ", max: " << checkReal(inst->fMax) + << ", init: " << checkReal(inst->fInit) + << ", step: " << checkReal(inst->fStep); + addMeta(); + fOut << " ]];"; + } else if (gGlobal->gOutputLang == "cmajor-hybrid") { + string cmajor_meta = getCmajorMetadata(); + fOut << "input event " << fTypeManager.fTypeDirectTable[itfloat()] + << " " << ((cmajor_meta != "") ? cmajor_meta : replaceCharList(inst->fLabel, gReplace, '_')) + << " [[ name: " << quote(inst->fLabel) + << ", group: " << quote(buildPath(inst->fLabel)) + << ", min: " << checkReal(inst->fMin) + << ", max: " << checkReal(inst->fMax) + << ", init: " << checkReal(inst->fInit) + << ", step: " << checkReal(inst->fStep); + addMeta(); + fOut << " ]];"; + } else { + fOut << "input event " << fTypeManager.fTypeDirectTable[itfloat()] + << " event" << inst->fZone + << " [[ name: " << quote(inst->fLabel) + << ", group: " << quote(buildPath(inst->fLabel)) + << ", min: " << checkReal(inst->fMin) + << ", max: " << checkReal(inst->fMax) + << ", init: " << checkReal(inst->fInit) + << ", step: " << checkReal(inst->fStep); + addMeta(); + fOut << " ]];"; + } + tab(fTab, fOut); + } + + virtual void visit(AddBargraphInst* inst) + { + // We have bargraphs + fHasBargraph = true; + + if (gGlobal->gOutputLang == "cmajor-poly") { + fOut << "output event " << fTypeManager.fTypeDirectTable[itfloat()] + << " event_" << quote(replaceCharList(inst->fLabel, gReplace, '_')) + << " [[ name: " << quote(inst->fLabel) + << ", group: " << quote(buildPath(inst->fLabel)) + << ", min: " << checkReal(inst->fMin) + << ", max: " << checkReal(inst->fMax); + addMeta(); + fOut << " ]];"; + } else if (gGlobal->gOutputLang == "cmajor-hybrid") { + string cmajor_meta = getCmajorMetadata(); + fOut << "output event " << fTypeManager.fTypeDirectTable[itfloat()] + << " " << ((cmajor_meta != "") ? cmajor_meta : replaceCharList(inst->fLabel, gReplace, '_')) + << " [[ name: " << quote(inst->fLabel) + << ", group: " << quote(buildPath(inst->fLabel)) + << ", min: " << checkReal(inst->fMin) + << ", max: " << checkReal(inst->fMax); + addMeta(); + fOut << " ]];"; + } else { + fOut << "output event " << fTypeManager.fTypeDirectTable[itfloat()] + << " event" << inst->fZone + << " [[ name: " << quote(inst->fLabel) + << ", group: " << quote(buildPath(inst->fLabel)) + << ", min: " << checkReal(inst->fMin) + << ", max: " << checkReal(inst->fMax); + addMeta(); + fOut << " ]];"; + } + tab(fTab, fOut); + } + + virtual void visit(OpenboxInst* inst) + { + switch (inst->fOrient) { + case OpenboxInst::kVerticalBox: + pushLabel("v:" + inst->fName); + break; + case OpenboxInst::kHorizontalBox: + pushLabel("h:" + inst->fName); + break; + case OpenboxInst::kTabBox: + pushLabel("t:" + inst->fName); + break; + } + fMetaAux.clear(); + } + + virtual void visit(CloseboxInst* inst) + { + popLabel(); + fMetaAux.clear(); + } + +}; + +class CmajorInstVisitor : public TextInstVisitor { + private: + // Polymorphic math functions + map gPolyMathLibTable; + + std::vector > fMetaAux; + + inline string checkFloat(float val) + { + return (std::isinf(val)) ? "inf" : T(val); + } + inline string checkDouble(double val) + { + return (std::isinf(val)) ? "inf" : T(val); + } + + std::string getCmajorMetadata() + { + if (fMetaAux.size() > 0) { + for (size_t i = 0; i < fMetaAux.size(); i++) { + if (fMetaAux[i].first == "cmajor") return fMetaAux[i].second; + } + } + return ""; + } + + public: + CmajorInstVisitor(std::ostream* out, int tab = 0) + : TextInstVisitor(out, ".", new CmajorStringTypeManager(xfloat(), ""), tab) + { + // Polymath mapping int version + gPolyMathLibTable["abs"] = "abs"; + gPolyMathLibTable["max_i"] = "max"; + gPolyMathLibTable["min_i"] = "min"; + + // Polymath mapping float version + gPolyMathLibTable["max_f"] = "max"; + gPolyMathLibTable["min_f"] = "min"; + + gPolyMathLibTable["fabsf"] = "abs"; + gPolyMathLibTable["acosf"] = "acos"; + gPolyMathLibTable["asinf"] = "asin"; + gPolyMathLibTable["atanf"] = "atan"; + gPolyMathLibTable["atan2f"] = "atan2"; + gPolyMathLibTable["ceilf"] = "ceil"; + gPolyMathLibTable["cosf"] = "cos"; + gPolyMathLibTable["expf"] = "exp"; + gPolyMathLibTable["exp2f"] = "exp2"; + gPolyMathLibTable["exp10f"] = "exp10f"; + gPolyMathLibTable["floorf"] = "floor"; + gPolyMathLibTable["fmodf"] = "fmod"; + gPolyMathLibTable["logf"] = "log"; + gPolyMathLibTable["log2f"] = "log2"; + gPolyMathLibTable["log10f"] = "log10"; + gPolyMathLibTable["powf"] = "pow"; + gPolyMathLibTable["remainderf"] = "remainder"; + gPolyMathLibTable["rintf"] = "rint"; + gPolyMathLibTable["roundf"] = "round"; + gPolyMathLibTable["sinf"] = "sin"; + gPolyMathLibTable["sqrtf"] = "sqrt"; + gPolyMathLibTable["tanf"] = "tan"; + + // Additional hyperbolic math functions are included in Cmajor + gPolyMathLibTable["acoshf"] = "acosh"; + gPolyMathLibTable["asinhf"] = "asinh"; + gPolyMathLibTable["atanhf"] = "atanh"; + gPolyMathLibTable["coshf"] = "cosh"; + gPolyMathLibTable["sinhf"] = "sinh"; + gPolyMathLibTable["tanhf"] = "tanh"; + + gPolyMathLibTable["isnanf"] = "isnan"; + gPolyMathLibTable["isinff"] = "isinf"; + // Manually implemented + gPolyMathLibTable["copysignf"] = "copysign"; + + // Polymath mapping double version + gPolyMathLibTable["max_"] = "max"; + gPolyMathLibTable["min_"] = "min"; + + gPolyMathLibTable["fabs"] = "abs"; + gPolyMathLibTable["acos"] = "acos"; + gPolyMathLibTable["asin"] = "asin"; + gPolyMathLibTable["atan"] = "atan"; + gPolyMathLibTable["atan2"] = "atan2"; + gPolyMathLibTable["ceil"] = "ceil"; + gPolyMathLibTable["cos"] = "cos"; + gPolyMathLibTable["exp"] = "exp"; + gPolyMathLibTable["exp2"] = "exp2"; + gPolyMathLibTable["exp10"] = "exp10"; + gPolyMathLibTable["floor"] = "floor"; + gPolyMathLibTable["fmod"] = "fmod"; + gPolyMathLibTable["log"] = "log"; + gPolyMathLibTable["log2"] = "log2"; + gPolyMathLibTable["log10"] = "log10"; + gPolyMathLibTable["pow"] = "pow"; + gPolyMathLibTable["remainder"] = "remainder"; + gPolyMathLibTable["rint"] = "rint"; + gPolyMathLibTable["round"] = "round"; + gPolyMathLibTable["sin"] = "sin"; + gPolyMathLibTable["sqrt"] = "sqrt"; + gPolyMathLibTable["tan"] = "tan"; + + // Additional hyperbolic math functions are included in Cmajor + gPolyMathLibTable["acosh"] = "acosh"; + gPolyMathLibTable["asinh"] = "asinh"; + gPolyMathLibTable["atanh"] = "atanh"; + gPolyMathLibTable["cosh"] = "cosh"; + gPolyMathLibTable["sinh"] = "sinh"; + gPolyMathLibTable["tanh"] = "tanh"; + + gPolyMathLibTable["isnan"] = "isnan"; + gPolyMathLibTable["isinf"] = "isinf"; + // Manually implemented + gPolyMathLibTable["copysignf"] = "copysign"; + } + + virtual ~CmajorInstVisitor() {} + + virtual void visit(AddMetaDeclareInst* inst) + { + fMetaAux.push_back(std::make_pair(inst->fKey, inst->fValue)); + } + + virtual void visit(OpenboxInst* inst) + { + fMetaAux.clear(); + } + + virtual void visit(CloseboxInst* inst) + { + fMetaAux.clear(); + } + + virtual void visit(AddButtonInst* inst) + { + *fOut << "// " << inst->fLabel; + EndLine(' '); + if (gGlobal->gOutputLang == "cmajor-poly") { + *fOut << "event event_" << replaceCharList(inst->fLabel, gReplace, '_') << " (" + << fTypeManager->fTypeDirectTable[itfloat()] << " val) { " << inst->fZone + << " = val; fUpdated = true; }"; + } else if (gGlobal->gOutputLang == "cmajor-hybrid") { + string cmajor_meta = getCmajorMetadata(); + *fOut << "event " << ((cmajor_meta != "") ? cmajor_meta : replaceCharList(inst->fLabel, gReplace, '_')) + << " (" << fTypeManager->fTypeDirectTable[itfloat()] << " val) { " + << inst->fZone << " = val; fUpdated = true; }"; + fMetaAux.clear(); + } else { + *fOut << "event event" << inst->fZone << " (" << fTypeManager->fTypeDirectTable[itfloat()] << " val) { " + << inst->fZone << " = val; fUpdated = true; }"; + } + EndLine(' '); + } + + virtual void visit(AddSliderInst* inst) + { + *fOut << "// " << inst->fLabel << " [init = " << checkReal(inst->fInit) + << ", min = " << checkReal(inst->fMin) << ", max = " << checkReal(inst->fMax) + << ", step = " << checkReal(inst->fStep) << "]"; + EndLine(' '); + if (gGlobal->gOutputLang == "cmajor-poly") { + *fOut << "event event_" << replaceCharList(inst->fLabel, gReplace, '_') << " (" + << fTypeManager->fTypeDirectTable[itfloat()] << " val) { " << inst->fZone + << " = val; fUpdated = true; }"; + } else if (gGlobal->gOutputLang == "cmajor-hybrid") { + string cmajor_meta = getCmajorMetadata(); + *fOut << "event " << ((cmajor_meta != "") ? cmajor_meta : replaceCharList(inst->fLabel, gReplace, '_')) + << " (" << fTypeManager->fTypeDirectTable[itfloat()] << " val) { " + << inst->fZone << " = val; fUpdated = true; }"; + fMetaAux.clear(); + } else { + *fOut << "event event" << inst->fZone << " (" << fTypeManager->fTypeDirectTable[itfloat()] << " val) { " + << inst->fZone << " = val; fUpdated = true; }"; + } + EndLine(' '); + } + + virtual void visit(AddBargraphInst* inst) + { + *fOut << "// " << inst->fLabel << " [min = " << checkReal(inst->fMin) << ", max = " << checkReal(inst->fMax) + << "]"; + EndLine(' '); + } + + virtual void visit(AddSoundfileInst* inst) + { + // Not supported for now + throw faustexception("ERROR : 'soundfile' primitive not yet supported for Cmajor\n"); + } + + virtual void visit(DeclareVarInst* inst) + { + string name = inst->fAddress->getName(); + + // special case for input/output considered as 'streams' + if (startWith(name, "input")) { + *fOut << "input stream " << fTypeManager->fTypeDirectTable[itfloat()] << " " << name; + } else if (startWith(name, "output")) { + *fOut << "output stream " << fTypeManager->fTypeDirectTable[itfloat()] << " " << name; + } else { + if (inst->fAddress->getAccess() & Address::kConst) { + *fOut << "const "; + } + *fOut << fTypeManager->generateType(inst->fType, name); + if (inst->fValue) { + *fOut << " = "; + inst->fValue->accept(this); + } + } + EndLine(); + } + + virtual void visit(DeclareFunInst* inst) {} + + /* + Indexed adresses can actually be values in an array or fields in a struct type + */ + virtual void visit(IndexedAddress* indexed) + { + indexed->fAddress->accept(this); + DeclareStructTypeInst* struct_type = isStructType(indexed->getName()); + if (struct_type) { + Int32NumInst* field_index = static_cast(indexed->getIndex()); + *fOut << "." << struct_type->fType->getName(field_index->fNum); + } else { + if (dynamic_cast(indexed->getIndex())) { + *fOut << "["; + indexed->getIndex()->accept(this); + *fOut << "]"; + } else { + // wrap code is automatically added by the Cmajor compiler (and the same if [idex] syntax is used) + *fOut << ".at ("; + indexed->getIndex()->accept(this); + *fOut << ")"; + } + } + } + + virtual void visit(StoreVarInst* inst) + { + string name = inst->fAddress->getName(); + // special case for 'output' considered as a 'stream' + if (startWith(name, "output")) { + inst->fAddress->accept(this); + *fOut << " <- "; + inst->fValue->accept(this); + EndLine(); + // special case for 'bargraph' considered as an 'output event' + } else if (startWith(name, "fHbargraph") || startWith(name, "fVbargraph")) { + // value is stored in the bargraph variable + { + inst->fAddress->accept(this); + *fOut << " = "; + inst->fValue->accept(this); + EndLine(); + } + // and the bargraph variable is sent using the 'output' event handler + { + *fOut << "if (fControlSlice == 0) { "; + *fOut << "event"; + inst->fAddress->accept(this); + *fOut << " <- "; + inst->fAddress->accept(this); + *fOut << "; }"; + tab(fTab, *fOut); + } + } else { + inst->fAddress->accept(this); + *fOut << " = "; + inst->fValue->accept(this); + EndLine(); + } + } + + virtual void visit(FloatNumInst* inst) { *fOut << checkFloat(inst->fNum); } + + virtual void visit(FloatArrayNumInst* inst) + { + char sep = '('; + for (size_t i = 0; i < inst->fNumTable.size(); i++) { + *fOut << sep << checkFloat(inst->fNumTable[i]); + sep = ','; + } + *fOut << ')'; + } + + virtual void visit(Int32ArrayNumInst* inst) + { + char sep = '('; + for (size_t i = 0; i < inst->fNumTable.size(); i++) { + *fOut << sep << inst->fNumTable[i]; + sep = ','; + } + *fOut << ')'; + } + + virtual void visit(Int64NumInst* inst) { *fOut << inst->fNum << "L"; } + + virtual void visit(DoubleNumInst* inst) { *fOut << checkDouble(inst->fNum); } + + virtual void visit(DoubleArrayNumInst* inst) + { + char sep = '('; + for (size_t i = 0; i < inst->fNumTable.size(); i++) { + *fOut << sep << checkDouble(inst->fNumTable[i]); + sep = ','; + } + *fOut << ')'; + } + + virtual void visit(::CastInst* inst) + { + string type = fTypeManager->generateType(inst->fType); + *fOut << type << " ("; + inst->fInst->accept(this); + *fOut << ")"; + } + + virtual void visit(BitcastInst* inst) { faustassert(false); } + + virtual void visitCond(ValueInst* cond) + { + *fOut << "bool ("; + cond->accept(this); + *fOut << ")"; + } + + virtual void visit(IfInst* inst) + { + *fOut << "if "; + visitCond(inst->fCond); + *fOut << " {"; + fTab++; + tab(fTab, *fOut); + inst->fThen->accept(this); + fTab--; + back(1, *fOut); + if (inst->fElse->fCode.size() > 0) { + *fOut << "} else {"; + fTab++; + tab(fTab, *fOut); + inst->fElse->accept(this); + fTab--; + back(1, *fOut); + *fOut << "}"; + } else { + *fOut << "}"; + } + tab(fTab, *fOut); + } + + virtual void visit(FunCallInst* inst) + { + string name; + if (gPolyMathLibTable.find(inst->fName) != gPolyMathLibTable.end()) { + name = gPolyMathLibTable[inst->fName]; + } else { + name = inst->fName; + } + + *fOut << gGlobal->getMathFunction(name) << ((inst->fArgs.size() > 0) ? " (" : "("); + + // Compile parameters + generateFunCallArgs(inst->fArgs.begin(), inst->fArgs.end(), inst->fArgs.size()); + *fOut << ")"; + } + + virtual void visit(ForLoopInst* inst) + { + // Don't generate empty loops... + if (inst->fCode->size() == 0) return; + + *fOut << "for ("; + + fFinishLine = false; + inst->fInit->accept(this); + *fOut << "; "; + + inst->fEnd->accept(this); + *fOut << "; "; + + inst->fIncrement->accept(this); + fFinishLine = true; + *fOut << ") {"; + + fTab++; + tab(fTab, *fOut); + inst->fCode->accept(this); + fTab--; + back(1, *fOut); + *fOut << "}"; + tab(fTab, *fOut); + } + + StringTypeManager* getTypeManager() { return fTypeManager; } +}; + +// For subcontainers: variable access is specific +class CmajorSubContainerInstVisitor : public CmajorInstVisitor { + public: + CmajorSubContainerInstVisitor(std::ostream* out, int tab = 0) : CmajorInstVisitor(out, tab) {} + + virtual void visit(NamedAddress* named) + { + if (named->getAccess() & Address::kStruct) { + *fOut << "this."; + } + *fOut << named->fName; + } +}; + +#endif diff -Nru faust-2.50.6+ds0/compiler/generator/code_container.cpp faust-2.54.9+ds0/compiler/generator/code_container.cpp --- faust-2.50.6+ds0/compiler/generator/code_container.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/code_container.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -835,7 +835,7 @@ BlockInst* block = InstBuilder::genBlockInst(); block->pushBackInst(fComputeBlockInstructions); // Hack for Julia - if (gGlobal->gOutputLang == "julia") { + if (gGlobal->gOutputLang == "julia" || gGlobal->gOutputLang == "jax") { block->pushBackInst(fCurLoop->generateSimpleScalarLoop("count")); } else { block->pushBackInst(fCurLoop->generateScalarLoop("count")); diff -Nru faust-2.50.6+ds0/compiler/generator/cpp/cpp_code_container.cpp faust-2.54.9+ds0/compiler/generator/cpp/cpp_code_container.cpp --- faust-2.50.6+ds0/compiler/generator/cpp/cpp_code_container.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/cpp/cpp_code_container.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -292,9 +292,9 @@ printLibrary(*fOut); printIncludeFile(*fOut); - if (gGlobal->gNameSpace != "" && gGlobal->gArchFile == "") { + if (gGlobal->gNamespace != "" && gGlobal->gArchFile == "") { tab(n, *fOut); - *fOut << "namespace " << gGlobal->gNameSpace << " {" << endl; + *fOut << "namespace " << gGlobal->gNamespace << " {" << endl; } tab(n, *fOut); @@ -660,9 +660,9 @@ // Generate user interface macros if needed printMacros(*fOut, n); - if (gGlobal->gNameSpace != "" && gGlobal->gArchFile == "") { + if (gGlobal->gNamespace != "" && gGlobal->gArchFile == "") { tab(n, *fOut); - *fOut << "} // namespace " << gGlobal->gNameSpace << endl; + *fOut << "} // namespace " << gGlobal->gNamespace << endl; } } @@ -675,9 +675,9 @@ printLibrary(*fOut); printIncludeFile(*fOut); - if (gGlobal->gNameSpace != "" && gGlobal->gArchFile == "") { + if (gGlobal->gNamespace != "" && gGlobal->gArchFile == "") { tab(n, *fOut); - *fOut << "namespace " << gGlobal->gNameSpace << " {" << endl; + *fOut << "namespace " << gGlobal->gNamespace << " {" << endl; } // Sub containers are merged in the main class @@ -826,11 +826,13 @@ } tab(n + 1, *fOut); + tab(n + 1, *fOut); *fOut << genVirtual() << "void instanceConstants(int sample_rate) {"; tab(n + 2, *fOut); fCodeProducer->Tab(n + 2); - generateInit(fCodeProducer); + // Rename 'sig' in 'dsp', remove 'dsp' allocation, inline subcontainers 'instanceInit' and 'fill' function call + inlineSubcontainersFunCalls(fInitInstructions)->accept(fCodeProducer); back(1, *fOut); *fOut << "}"; tab(n + 1, *fOut); @@ -933,9 +935,9 @@ // Generate user interface macros if needed printMacros(*fOut, n); - if (gGlobal->gNameSpace != "" && gGlobal->gArchFile == "") { + if (gGlobal->gNamespace != "" && gGlobal->gArchFile == "") { tab(n, *fOut); - *fOut << "} // namespace " << gGlobal->gNameSpace << endl; + *fOut << "} // namespace " << gGlobal->gNamespace << endl; } } @@ -948,9 +950,9 @@ printLibrary(*fOut); printIncludeFile(*fOut); - if (gGlobal->gNameSpace != "" && gGlobal->gArchFile == "") { + if (gGlobal->gNamespace != "" && gGlobal->gArchFile == "") { tab(n, *fOut); - *fOut << "namespace " << gGlobal->gNameSpace << " {" << endl; + *fOut << "namespace " << gGlobal->gNamespace << " {" << endl; } // Sub containers are merged in the main class @@ -1103,7 +1105,8 @@ *fOut << genVirtual() << "void instanceConstants(int sample_rate, " << subst("int* iZone, $0* fZone) {", ifloat()); tab(n + 2, *fOut); fCodeProducer->Tab(n + 2); - generateInit(fCodeProducer); + // Rename 'sig' in 'dsp', remove 'dsp' allocation, inline subcontainers 'instanceInit' and 'fill' function call + inlineSubcontainersFunCalls(fInitInstructions)->accept(fCodeProducer); back(1, *fOut); *fOut << "}"; tab(n + 1, *fOut); @@ -1223,9 +1226,9 @@ // Generate user interface macros if needed printMacros(*fOut, n); - if (gGlobal->gNameSpace != "" && gGlobal->gArchFile == "") { + if (gGlobal->gNamespace != "" && gGlobal->gArchFile == "") { tab(n, *fOut); - *fOut << "} // namespace " << gGlobal->gNameSpace << endl; + *fOut << "} // namespace " << gGlobal->gNamespace << endl; } } @@ -1245,9 +1248,9 @@ printLibrary(*fOut); printIncludeFile(*fOut); - if (gGlobal->gNameSpace != "" && gGlobal->gArchFile == "") { + if (gGlobal->gNamespace != "" && gGlobal->gArchFile == "") { tab(n, *fOut); - *fOut << "namespace " << gGlobal->gNameSpace << " {" << endl; + *fOut << "namespace " << gGlobal->gNamespace << " {" << endl; } // Sub containers are merged in the main class @@ -1400,7 +1403,8 @@ *fOut << genVirtual() << "void instanceConstants(int sample_rate, " << subst("int* iZone, $0* fZone) {", ifloat()); tab(n + 2, *fOut); fCodeProducer->Tab(n + 2); - generateInit(fCodeProducer); + // Rename 'sig' in 'dsp', remove 'dsp' allocation, inline subcontainers 'instanceInit' and 'fill' function call + inlineSubcontainersFunCalls(fInitInstructions)->accept(fCodeProducer); back(1, *fOut); *fOut << "}"; tab(n + 1, *fOut); @@ -1408,9 +1412,11 @@ tab(n + 1, *fOut); *fOut << genVirtual() << "void instanceConstantsFromMem(int sample_rate, " << subst("int* iZone, $0* fZone) {", ifloat()); tab(n + 2, *fOut); + // Rename 'sig' in 'dsp', remove 'dsp' allocation, inline subcontainers 'instanceInit' and 'fill' function call + BlockInst* block1 = inlineSubcontainersFunCalls(fInitInstructions); ConstantsCopyFromMemory copy_from_mem(int_zone_size, real_zone_size); CPPInstVisitor visitor1(fOut, n + 2); - copy_from_mem.getCode(fInitInstructions)->accept(&visitor1); + copy_from_mem.getCode(block1)->accept(&visitor1); back(1, *fOut); *fOut << "}"; tab(n + 1, *fOut); @@ -1418,9 +1424,11 @@ tab(n + 1, *fOut); *fOut << genVirtual() << "void instanceConstantsToMem(int sample_rate, " << subst("int* iZone, $0* fZone) {", ifloat()); tab(n + 2, *fOut); + // Rename 'sig' in 'dsp', remove 'dsp' allocation, inline subcontainers 'instanceInit' and 'fill' function call + BlockInst* block2 = inlineSubcontainersFunCalls(fInitInstructions); ConstantsCopyToMemory copy_to_mem(int_zone_size, real_zone_size); CPPInstVisitor visitor2(fOut, n + 2); - copy_to_mem.getCode(fInitInstructions)->accept(&visitor2); + copy_to_mem.getCode(block2)->accept(&visitor2); back(1, *fOut); *fOut << "}"; tab(n + 1, *fOut); @@ -1543,9 +1551,9 @@ // Generate user interface macros if needed printMacros(*fOut, n); - if (gGlobal->gNameSpace != "" && gGlobal->gArchFile == "") { + if (gGlobal->gNamespace != "" && gGlobal->gArchFile == "") { tab(n, *fOut); - *fOut << "} // namespace " << gGlobal->gNameSpace << endl; + *fOut << "} // namespace " << gGlobal->gNamespace << endl; } } @@ -1565,9 +1573,9 @@ printLibrary(*fOut); printIncludeFile(*fOut); - if (gGlobal->gNameSpace != "" && gGlobal->gArchFile == "") { + if (gGlobal->gNamespace != "" && gGlobal->gArchFile == "") { tab(n, *fOut); - *fOut << "namespace " << gGlobal->gNameSpace << " {" << endl; + *fOut << "namespace " << gGlobal->gNamespace << " {" << endl; } // Sub containers are merged in the main class @@ -1720,7 +1728,8 @@ *fOut << genVirtual() << "void instanceConstants(int sample_rate) {"; tab(n + 2, *fOut); fCodeProducer->Tab(n + 2); - generateInit(fCodeProducer); + // Rename 'sig' in 'dsp', remove 'dsp' allocation, inline subcontainers 'instanceInit' and 'fill' function call + inlineSubcontainersFunCalls(fInitInstructions)->accept(fCodeProducer); back(1, *fOut); *fOut << "}"; tab(n + 1, *fOut); @@ -1728,9 +1737,11 @@ tab(n + 1, *fOut); *fOut << genVirtual() << "void instanceConstantsFromMem(int sample_rate) {"; tab(n + 2, *fOut); + // Rename 'sig' in 'dsp', remove 'dsp' allocation, inline subcontainers 'instanceInit' and 'fill' function call + BlockInst* block1 = inlineSubcontainersFunCalls(fInitInstructions); ConstantsCopyFromMemory1 copy_from_mem(int_zone_size, real_zone_size); CPPInstVisitor visitor1(fOut, n + 2); - copy_from_mem.getCode(fInitInstructions)->accept(&visitor1); + copy_from_mem.getCode(block1)->accept(&visitor1); back(1, *fOut); *fOut << "}"; tab(n + 1, *fOut); @@ -1738,9 +1749,11 @@ tab(n + 1, *fOut); *fOut << genVirtual() << "void instanceConstantsToMem(int sample_rate) {"; tab(n + 2, *fOut); + // Rename 'sig' in 'dsp', remove 'dsp' allocation, inline subcontainers 'instanceInit' and 'fill' function call + BlockInst* block2 = inlineSubcontainersFunCalls(fInitInstructions); ConstantsCopyToMemory1 copy_to_mem(int_zone_size, real_zone_size); CPPInstVisitor visitor2(fOut, n + 2); - copy_to_mem.getCode(fInitInstructions)->accept(&visitor2); + copy_to_mem.getCode(block2)->accept(&visitor2); // Keep the updated values int_zone_size = copy_from_mem.fIntIndex; real_zone_size = copy_from_mem.fRealIndex; @@ -1931,9 +1944,9 @@ // Generate user interface macros if needed printMacros(*fOut, n); - if (gGlobal->gNameSpace != "" && gGlobal->gArchFile == "") { + if (gGlobal->gNamespace != "" && gGlobal->gArchFile == "") { tab(n, *fOut); - *fOut << "} // namespace " << gGlobal->gNameSpace << endl; + *fOut << "} // namespace " << gGlobal->gNamespace << endl; } } diff -Nru faust-2.50.6+ds0/compiler/generator/description.cpp faust-2.54.9+ds0/compiler/generator/description.cpp --- faust-2.50.6+ds0/compiler/generator/description.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/description.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -144,7 +144,7 @@ default: { stringstream error; error << "ERROR unrecognized state " << state << endl; - gGlobal->gErrorMsg = error.str(); + gGlobal->gErrorMessage = error.str(); } } } diff -Nru faust-2.50.6+ds0/compiler/generator/dlang/dlang_code_container.cpp faust-2.54.9+ds0/compiler/generator/dlang/dlang_code_container.cpp --- faust-2.50.6+ds0/compiler/generator/dlang/dlang_code_container.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/dlang/dlang_code_container.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -241,8 +241,9 @@ { string moduleName = klassName; transform(moduleName.begin(), moduleName.end(), moduleName.begin(), ::tolower); - if (gGlobal->gNameSpace != "") - moduleName = gGlobal->gNameSpace + "." + moduleName; + if (gGlobal->gNamespace != "") { + moduleName = gGlobal->gNamespace + "." + moduleName; + } return moduleName; } diff -Nru faust-2.50.6+ds0/compiler/generator/dsp_aux.cpp faust-2.54.9+ds0/compiler/generator/dsp_aux.cpp --- faust-2.50.6+ds0/compiler/generator/dsp_aux.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/dsp_aux.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -230,7 +230,7 @@ Same DSP code and same normalized compilation options will generate the same SHA key. */ LIBFAUST_API string expandDSPFromString(const string& name_app, const string& dsp_content, int argc, const char* argv[], - string& sha_key, string& error_msg) + string& sha_key, string& error_msg) { LOCK_API if (dsp_content == "") { @@ -260,7 +260,7 @@ argv1[argc1] = nullptr; // NULL terminated argv // 'expandDsp' adds the normalized compilation options in the DSP code before computing the SHA key - return expandDSP(argc1, argv1, name_app.c_str(), dsp_content.c_str(), sha_key, error_msg); + return expandDSP(name_app, dsp_content, argc1, argv1, sha_key, error_msg); } } @@ -291,7 +291,7 @@ } argv1[argc1] = nullptr; // NULL terminated argv - dsp_factory_base* factory = createFactory(name_app.c_str(), dsp_content.c_str(), argc1, argv1, error_msg, false); + dsp_factory_base* factory = createFactory(name_app, dsp_content, argc1, argv1, error_msg, false); // Factory is no more needed delete factory; return (factory != nullptr); @@ -305,7 +305,7 @@ #endif LIBFAUST_API const char* expandCDSPFromFile(const char* filename, int argc, const char* argv[], char* sha_key, - char* error_msg) + char* error_msg) { string sha_key_aux; string error_msg_aux; diff -Nru faust-2.50.6+ds0/compiler/generator/export.cpp faust-2.54.9+ds0/compiler/generator/export.cpp --- faust-2.50.6+ds0/compiler/generator/export.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/export.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -20,9 +20,17 @@ ************************************************************************/ #include +#include #include "faust/export.h" +/* + Global outside of the global context, compiled here + to be defined in libfaust and libfaustmachine libraries. +*/ +std::vector gWarningMessages; +bool gAllWarning = false; + // External libfaust API extern "C" LIBFAUST_API const char* getCLibFaustVersion() @@ -36,7 +44,6 @@ } /* - Regular C++ exceptions are deactivated when compiled with 'emcc' since adding them (using Emscripten runtime mechanism) practically doubles the size of the generated wasm library. @@ -47,7 +54,6 @@ - a regular JS exception is triggered and catched on JS side - the actual exception message is retrieved on JS side using 'getErrorAfterException' - and finally global context cleanup is done from JS side using 'cleanupAfterException' - */ #ifdef EMCC diff -Nru faust-2.50.6+ds0/compiler/generator/fir/fir_instructions.hh faust-2.54.9+ds0/compiler/generator/fir/fir_instructions.hh --- faust-2.50.6+ds0/compiler/generator/fir/fir_instructions.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/fir/fir_instructions.hh 2022-12-17 10:41:42.000000000 +0000 @@ -458,6 +458,18 @@ } *fOut << '}'; } + + virtual void visit(FixedPointNumInst* inst) { *fOut << "FixedPoint(" << checkFloat(inst->fNum) << ")"; } + + virtual void visit(FixedPointArrayNumInst* inst) + { + char sep = '{'; + for (size_t i = 0; i < inst->fNumTable.size(); i++) { + *fOut << sep << "FixedPoint(" << checkFloat(inst->fNumTable[i]) << ")"; + sep = ','; + } + *fOut << '}'; + } virtual void visit(BinopInst* inst) { diff -Nru faust-2.50.6+ds0/compiler/generator/fir_to_fir.hh faust-2.54.9+ds0/compiler/generator/fir_to_fir.hh --- faust-2.50.6+ds0/compiler/generator/fir_to_fir.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/fir_to_fir.hh 2022-12-17 10:41:42.000000000 +0000 @@ -693,16 +693,23 @@ // Base class for iConst/fConst memory copy in -osX modes struct ConstantsCopyMemory : public BasicCloneVisitor { + // Additional variables are added at the end of iZone/fZone arrays int fIntIndex = 0; int fRealIndex = 0; ConstantsCopyMemory(int int_index, int float_index):fIntIndex(int_index), fRealIndex(float_index) {} + // Removed instructions StatementInst* visit(DeclareVarInst* inst) { return InstBuilder::genDropInst(); } + + StatementInst* visit(ForLoopInst* inst) + { + return InstBuilder::genDropInst(); + } }; diff -Nru faust-2.50.6+ds0/compiler/generator/floats.cpp faust-2.54.9+ds0/compiler/generator/floats.cpp --- faust-2.50.6+ds0/compiler/generator/floats.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/floats.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -129,6 +129,44 @@ floatmin[2] = DBL_MIN; floatmin[3] = LDBL_MIN; floatmin[4] = FLT_MIN; + + // Specific for JAX backend + } else if (gGlobal->gOutputLang == "jax") { + numsuffix[0] = ""; + numsuffix[1] = ""; + numsuffix[2] = ""; + numsuffix[3] = ""; + numsuffix[4] = ""; + + floatname[0] = FLOATMACRO; + floatname[1] = "jnp.float32"; + floatname[2] = "jnp.float64"; + floatname[3] = "dummy"; + floatname[4] = "dummy"; + + floatptrname[0] = FLOATMACROPTR; + floatptrname[1] = "jnp.float32*"; + floatptrname[2] = "jnp.float64*"; + floatptrname[3] = "dummy*"; + floatptrname[4] = "dummy*"; + + floatptrptrname[0] = FLOATMACROPTRPTR; + floatptrptrname[1] = "jnp.float32**"; + floatptrptrname[2] = "jnp.float64**"; + floatptrptrname[3] = "dummy**"; + floatptrptrname[4] = "dummy**"; + + castname[0] = FLOATCASTER; + castname[1] = "(jnp.float32)"; + castname[2] = "(jnp.float64)"; + castname[3] = "(dummy)"; + castname[4] = "(dummy)"; + + floatmin[0] = 0; + floatmin[1] = FLT_MIN; + floatmin[2] = DBL_MIN; + floatmin[3] = LDBL_MIN; + floatmin[4] = FLT_MIN; // Specific for D backend } else if (gGlobal->gOutputLang == "dlang") { diff -Nru faust-2.50.6+ds0/compiler/generator/instructions_compiler.cpp faust-2.54.9+ds0/compiler/generator/instructions_compiler.cpp --- faust-2.50.6+ds0/compiler/generator/instructions_compiler.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/instructions_compiler.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -28,6 +28,7 @@ #include "instructions.hh" #include "instructions_compiler.hh" #include "instructions_compiler1.hh" +#include "instructions_compiler_jax.hh" #include "prim2.hh" #include "privatise.hh" #include "recursivness.hh" @@ -38,6 +39,8 @@ #include "normalform.hh" #include "timing.hh" #include "sigtyperules.hh" +#include "signalVisitor.hh" +#include "sigPromotion.hh" using namespace std; @@ -111,7 +114,7 @@ } else { // it is our first visit, int v = getCertifiedSigType(sig)->variability(); - + // check "time sharing" cases if (v < vctxt) { setSharingCount(sig, 2); // time sharing occurence : slower expression in faster context @@ -228,6 +231,14 @@ startTiming("prepare"); Tree L1 = simplifyToNormalForm(LS); + /* + Possibly cast bool binary operations (comparison operations) to int. + Done after simplifyToNormalForm with does SignalTreeChecker, + that would fail after sigBool2IntPromote which adds additional + sigIntCast on bool producing BinOp operations. + */ + if (gGlobal->gBool2Int) L1 = sigBool2IntPromote(L1); + // dump normal form if (gGlobal->gDumpNorm == 0) { cout << ppsig(L1) << endl; @@ -390,6 +401,9 @@ if (gGlobal->gOutputLang == "rust" || gGlobal->gOutputLang == "julia") { InstructionsCompiler1 C(container); C.compileSingleSignal(sig); + } else if (gGlobal->gOutputLang == "jax") { + InstructionsCompilerJAX C(container); + C.compileSingleSignal(sig); } else { InstructionsCompiler C(container); C.compileSingleSignal(sig); @@ -468,12 +482,40 @@ void InstructionsCompiler::compileMultiSignal(Tree L) { + // Compile inputs + struct InputCompiler : public SignalVisitor { + + InstructionsCompiler* fComp; + + InputCompiler(Tree L, InstructionsCompiler* comp) + { + fComp = comp; + while (!isNil(L)) { + self(hd(L)); + L = tl(L); + } + } + + void visit(Tree sig) + { + int input; + if (isSigInput(sig, &input)) { + fComp->CS(sig); + } else { + SignalVisitor::visit(sig); + } + } + }; + startTiming("compileMultiSignal"); // Has to be done *after* gMachinePtrSize is set by the actual backend gGlobal->initTypeSizeMap(); L = prepare(L); // Optimize, share and annotate expression + + // Compile inputs when gInPlace (force caching for in-place transformations) + if (gGlobal->gInPlace) InputCompiler(L, this); #ifdef LLVM_DEBUG // Add function declaration @@ -495,15 +537,12 @@ } else if (gGlobal->gOutputLang == "julia") { // special handling Julia backend pushComputeBlockMethod(InstBuilder::genDeclareBufferIterators("input", "inputs", fContainer->inputs(), ptr_type, false)); - } else { + } else if (gGlobal->gOutputLang != "jax") { // "input" and "inputs" used as a name convention if (gGlobal->gOneSampleControl) { for (int index = 0; index < fContainer->inputs(); index++) { string name = subst("input$0", T(index)); pushDeclare(InstBuilder::genDecStructVar(name, type)); - if (gGlobal->gInPlace) { - CS(sigInput(index)); - } } } else if (gGlobal->gOneSample >= 0) { // Nothing... @@ -512,9 +551,6 @@ string name = subst("input$0", T(index)); pushComputeBlockMethod(InstBuilder::genDecStackVar(name, ptr_type, InstBuilder::genLoadArrayFunArgsVar("inputs", InstBuilder::genInt32NumInst(index)))); - if (gGlobal->gInPlace) { - CS(sigInput(index)); - } } } } @@ -526,8 +562,7 @@ } else if (gGlobal->gOutputLang == "julia") { // special handling for Julia backend pushComputeBlockMethod(InstBuilder::genDeclareBufferIterators("output", "outputs", fContainer->outputs(), ptr_type, true)); - - } else { + } else if (gGlobal->gOutputLang != "jax") { // "output" and "outputs" used as a name convention if (gGlobal->gOneSampleControl) { for (int index = 0; index < fContainer->outputs(); index++) { @@ -546,6 +581,10 @@ } } + // These two vars are only used for JAX + std::string return_string = "state, jnp.stack(["; + std::string sep = ""; + for (int index = 0; isList(L); L = tl(L), index++) { Tree sig = hd(L); @@ -557,6 +596,12 @@ if (gGlobal->gOutputLang == "rust") { name = subst("*output$0", T(index)); pushComputeDSPMethod(InstBuilder::genStoreStackVar(name, res)); + } else if (gGlobal->gOutputLang == "jax") { + res = CS(sig); + string result_var = "_result" + to_string(index); + return_string = return_string + sep + result_var; + sep = ","; + pushComputeDSPMethod(InstBuilder::genStoreStackVar(result_var, res)); } else if (gGlobal->gOneSampleControl) { name = subst("output$0", T(index)); if (gGlobal->gComputeMix) { @@ -584,6 +629,11 @@ } } + if (gGlobal->gOutputLang == "jax") { + return_string = return_string + "])"; + pushPostComputeDSPMethod(InstBuilder::genRetInst(InstBuilder::genLoadStackVar(return_string))); + } + Tree ui = InstructionsCompiler::prepareUserInterfaceTree(fUIRoot); generateUserInterfaceTree(ui, true); generateMacroInterfaceTree("", ui); @@ -877,6 +927,8 @@ // HACK for Rust backend if (gGlobal->gOutputLang == "rust") { res = InstBuilder::genLoadStackVar(subst("*input$0", T(idx))); + } else if (gGlobal->gOutputLang == "jax") { + res = InstBuilder::genLoadArrayStackVar("inputs", InstBuilder::genInt32NumInst(idx)); } else if (gGlobal->gOneSampleControl) { res = InstBuilder::genLoadStructVar(subst("input$0", T(idx))); } else if (gGlobal->gOneSample >= 0) { @@ -1001,7 +1053,7 @@ if (getCompiledExpression(sig, code)) { return code; } - + string vname; Typed::VarType ctype; old_Occurences* o = fOccMarkup->retrieve(sig); @@ -1404,7 +1456,7 @@ throw faustexception(error.str()); } - ValueInst* generator = CS(content); + ValueInst* signame = CS(content); Typed::VarType ctype; Tree g; string vname; @@ -1429,10 +1481,10 @@ if (gGlobal->gOutputLang != "rust" && gGlobal->gOutputLang != "julia") { // Delete object Values args3; + args3.push_back(signame); if (gGlobal->gMemoryManager && (gGlobal->gOneSample == -1)) { args3.push_back(InstBuilder::genLoadStaticStructVar("fManager")); } - args3.push_back(generator); pushPostInitMethod(InstBuilder::genVoidFunCallInst("delete" + kvnames.first, args3)); } } @@ -1449,13 +1501,13 @@ // Init content generator Values args1; - args1.push_back(generator); + args1.push_back(signame); args1.push_back(InstBuilder::genLoadFunArgsVar("sample_rate")); pushInitMethod(InstBuilder::genVoidFunCallInst("instanceInit" + tablename, args1, true)); // Fill the table Values args2; - args2.push_back(generator); + args2.push_back(signame); args2.push_back(InstBuilder::genInt32NumInst(size)); // HACK for Rust backend args2.push_back(InstBuilder::genLoadMutRefStructVar(vname)); @@ -1475,14 +1527,14 @@ } Tree g; - ValueInst* cexp; + ValueInst* signame; Typed::VarType ctype; string vname; ensure(isSigGen(content, g)); - if (!getCompiledExpression(content, cexp)) { - cexp = setCompiledExpression(content, generateStaticSigGen(content, g)); + if (!getCompiledExpression(content, signame)) { + signame = setCompiledExpression(content, generateStaticSigGen(content, g)); } else { // already compiled but check if we need to add declarations pair kvnames; @@ -1503,10 +1555,10 @@ if (gGlobal->gOutputLang != "rust" && gGlobal->gOutputLang != "julia") { // Delete object Values args3; + args3.push_back(signame); if (gGlobal->gMemoryManager && (gGlobal->gOneSample == -1)) { args3.push_back(InstBuilder::genLoadStaticStructVar("fManager")); } - args3.push_back(cexp); pushPostInitMethod(InstBuilder::genVoidFunCallInst("delete" + kvnames.first, args3)); } } @@ -1533,7 +1585,7 @@ // Init content generator Values args1; - args1.push_back(cexp); + args1.push_back(signame); args1.push_back(InstBuilder::genLoadFunArgsVar("sample_rate")); pushStaticInitMethod(InstBuilder::genVoidFunCallInst("instanceInit" + tablename, args1, true)); @@ -1553,7 +1605,7 @@ // Fill the table Values args2; - args2.push_back(cexp); + args2.push_back(signame); args2.push_back(InstBuilder::genInt32NumInst(size)); // HACK for Rust backend args2.push_back(InstBuilder::genLoadStaticMutRefStructVar(vname)); @@ -1573,29 +1625,6 @@ LoadVarInst* load_value = dynamic_cast(tblname); faustassert(load_value); - Tree id, size, content; - if (isSigTable(tbl, id, size, content)) { - // Check write access - if (gGlobal->gCheckTable != "") { - // Check if index is inside the table range (to rework with a low, high, impose interval model) - interval idx_i = getCertifiedSigType(idx)->getInterval(); - if (idx_i.lo < 0 || idx_i.hi >= tree2int(size)) { - stringstream error; - if (gGlobal->gCheckTable == "cat") { - error << "WARNING : WRTbl write index [" << idx_i.lo << ":" <fAddress->getName(); @@ -1632,25 +1661,6 @@ Address::AccessType access; if (isSigTable(tbl, id, size, content)) { - // Check read access - if (gGlobal->gCheckTable != "") { - // Check if index is inside the table range (to rework with a low, high, impose interval model) - interval idx_i = getCertifiedSigType(idx)->getInterval(); - if (idx_i.lo < 0 || (idx_i.hi >= tree2int(size))) { - stringstream error; - if (gGlobal->gCheckTable == "cat") { - error << "WARNING : RDTbl read index [" << idx_i.lo << ":" <variability()) { - - case kBlock: - // Local variable is only created if needed that is if the expression - // is not already a 'simple value', constant or variable - if (!v1->isSimpleValue()) { - pushComputeBlockMethod(InstBuilder::genDecStackVar(v_then, InstBuilder::genBasicTyped(t_then), v1)); - v1 = InstBuilder::genLoadStackVar(v_then); - } - if (!v2->isSimpleValue()) { - pushComputeBlockMethod(InstBuilder::genDecStackVar(v_else, InstBuilder::genBasicTyped(t_else), v2)); - v2 = InstBuilder::genLoadStackVar(v_else); - } - break; - - case kSamp: - // Local variable is only created if needed that is if the expression - // is not already a 'simple value', constant or variable - if (!v1->isSimpleValue()) { - pushComputeDSPMethod(InstBuilder::genDecStackVar(v_then, InstBuilder::genBasicTyped(t_then), v1)); - v1 = InstBuilder::genLoadStackVar(v_then); - } - if (!v2->isSimpleValue()) { - pushComputeDSPMethod(InstBuilder::genDecStackVar(v_else, InstBuilder::genBasicTyped(t_else), v2)); - v2 = InstBuilder::genLoadStackVar(v_else); - } - break; + if (gGlobal->gStrictSelect) { + + ::Type ct1 = getCertifiedSigType(s1); + ::Type ct2 = getCertifiedSigType(s2); + + string v_then, v_else; + Typed::VarType t_then, t_else; + getTypedNames(ct1, "Then", t_then, v_then); + getTypedNames(ct2, "Else", t_else, v_else); + + // Create local variables to force proper execution of both branches of 'select2' + switch (getCertifiedSigType(sig)->variability()) { + + case kBlock: + // Local variable is only created if needed that is if the expression + // is not already a 'simple value', constant or variable + if (!v1->isSimpleValue()) { + pushComputeBlockMethod(InstBuilder::genDecStackVar(v_then, InstBuilder::genBasicTyped(t_then), v1)); + v1 = InstBuilder::genLoadStackVar(v_then); + } + if (!v2->isSimpleValue()) { + pushComputeBlockMethod(InstBuilder::genDecStackVar(v_else, InstBuilder::genBasicTyped(t_else), v2)); + v2 = InstBuilder::genLoadStackVar(v_else); + } + break; + + case kSamp: + // Local variable is only created if needed that is if the expression + // is not already a 'simple value', constant or variable + if (!v1->isSimpleValue()) { + pushComputeDSPMethod(InstBuilder::genDecStackVar(v_then, InstBuilder::genBasicTyped(t_then), v1)); + v1 = InstBuilder::genLoadStackVar(v_then); + } + if (!v2->isSimpleValue()) { + pushComputeDSPMethod(InstBuilder::genDecStackVar(v_else, InstBuilder::genBasicTyped(t_else), v2)); + v2 = InstBuilder::genLoadStackVar(v_else); + } + break; + } } return generateCacheCode(sig, InstBuilder::genSelect2Inst(cond, v2, v1)); @@ -2466,7 +2479,7 @@ Tree path, c, x, y, z; string label; map> metadata; - + extractMetadata(tree2str(fulllabel), label, metadata); string pathlabel = pathname + label; string rawlabel = label; diff -Nru faust-2.50.6+ds0/compiler/generator/instructions_compiler_jax.cpp faust-2.54.9+ds0/compiler/generator/instructions_compiler_jax.cpp --- faust-2.50.6+ds0/compiler/generator/instructions_compiler_jax.cpp 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/instructions_compiler_jax.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,159 @@ +/************************************************************************ + ************************************************************************ + FAUST compiler + Copyright (C) 2017-2021 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., 675 Mass Ave, Cambridge, MA 02139, USA. + ************************************************************************ + ************************************************************************/ + +#include "instructions_compiler_jax.hh" +#include "ensure.hh" +#include "ppsig.hh" +#include "sigtyperules.hh" + +StatementInst* InstructionsCompilerJAX::generateShiftArray(const string& vname, int delay) +{ + Values truncated_args; + truncated_args.push_back(InstBuilder::genLoadArrayStructVar(vname)); + truncated_args.push_back(InstBuilder::genLoadStackVar("1")); + return InstBuilder::genStoreArrayStructVar(vname, InstBuilder::genFunCallInst(string("jnp.roll"), truncated_args)); +} + +ValueInst* InstructionsCompilerJAX::generateDelayLine(ValueInst* exp, Typed::VarType ctype, const string& vname, + int mxd, Address::AccessType& var_access, ValueInst* ccs) +{ + if (mxd == 0) { + // Generate scalar use + if (dynamic_cast(ccs)) { + pushComputeDSPMethod(InstBuilder::genDecStackVar(vname, InstBuilder::genBasicTyped(ctype), exp)); + } else { + pushPreComputeDSPMethod(InstBuilder::genDecStackVar(vname, InstBuilder::genBasicTyped(ctype), + InstBuilder::genTypedZero(ctype))); + pushComputeDSPMethod(InstBuilder::genControlInst(ccs, InstBuilder::genStoreStackVar(vname, exp))); + } + + } else if (mxd < gGlobal->gMaxCopyDelay) { + // Generates table init + generateInitArray(vname, ctype, mxd + 1); + + // Generate table use + pushComputeDSPMethod(InstBuilder::genControlInst( + ccs, InstBuilder::genStoreArrayStructVar(vname, InstBuilder::genInt32NumInst(0), exp))); + + // Generates post processing copy code to update delay values + pushPostComputeDSPMethod(InstBuilder::genControlInst(ccs, generateShiftArray(vname, mxd))); + + } else { + int N = pow2limit(mxd + 1); + if (N <= gGlobal->gMaskDelayLineThreshold) { + ensureIotaCode(); + + // Generates table init + generateInitArray(vname, ctype, N); + + // Generate table use + if (gGlobal->gComputeIOTA) { // Ensure IOTA base fixed delays are computed once + if (fIOTATable.find(N) == fIOTATable.end()) { + string iota_name = subst("i$0", gGlobal->getFreshID(fCurrentIOTA + "_temp")); + FIRIndex value2 = FIRIndex(InstBuilder::genLoadStructVar(fCurrentIOTA)) & FIRIndex(N - 1); + + pushPreComputeDSPMethod(InstBuilder::genDecStackVar(iota_name, InstBuilder::genInt32Typed(), + InstBuilder::genInt32NumInst(0))); + pushComputeDSPMethod( + InstBuilder::genControlInst(ccs, InstBuilder::genStoreStackVar(iota_name, value2))); + + fIOTATable[N] = iota_name; + } + + pushComputeDSPMethod(InstBuilder::genControlInst( + ccs, InstBuilder::genStoreArrayStructVar(vname, InstBuilder::genLoadStackVar(fIOTATable[N]), exp))); + + } else { + FIRIndex value2 = FIRIndex(InstBuilder::genLoadStructVar(fCurrentIOTA)) & FIRIndex(N - 1); + pushComputeDSPMethod( + InstBuilder::genControlInst(ccs, InstBuilder::genStoreArrayStructVar(vname, value2, exp))); + } + } else { + // 'select' based delay + string widx_tmp_name = vname + "_widx_tmp"; + string widx_name = vname + "_widx"; + + // Generates table write index + pushDeclare(InstBuilder::genDecStructVar(widx_name, InstBuilder::genInt32Typed())); + pushInitMethod(InstBuilder::genStoreStructVar(widx_name, InstBuilder::genInt32NumInst(0))); + + // Generates table init + generateInitArray(vname, ctype, mxd + 1); + + // int w = widx; + pushComputeDSPMethod(InstBuilder::genControlInst( + ccs, InstBuilder::genDecStackVar(widx_tmp_name, InstBuilder::genBasicTyped(Typed::kInt32), + InstBuilder::genLoadStructVar(widx_name)))); + + // dline[w] = v; + pushComputeDSPMethod(InstBuilder::genControlInst( + ccs, InstBuilder::genStoreArrayStructVar(vname, InstBuilder::genLoadStackVar(widx_tmp_name), exp))); + + // w = w + 1; + FIRIndex widx_tmp1 = FIRIndex(InstBuilder::genLoadStackVar(widx_tmp_name)); + pushPostComputeDSPMethod( + InstBuilder::genControlInst(ccs, InstBuilder::genStoreStackVar(widx_tmp_name, widx_tmp1 + 1))); + + // w = ((w == delay) ? 0 : w); + FIRIndex widx_tmp2 = FIRIndex(InstBuilder::genLoadStackVar(widx_tmp_name)); + pushPostComputeDSPMethod(InstBuilder::genControlInst( + ccs, + InstBuilder::genStoreStackVar(widx_tmp_name, InstBuilder::genSelect2Inst(widx_tmp2 == FIRIndex(mxd + 1), + FIRIndex(0), widx_tmp2)))); + // *widx = w + pushPostComputeDSPMethod(InstBuilder::genControlInst( + ccs, InstBuilder::genStoreStructVar(widx_name, InstBuilder::genLoadStackVar(widx_tmp_name)))); + } + } + + return exp; +} + +ValueInst* InstructionsCompilerJAX::generateSoundfile(Tree sig, Tree path) +{ + string varname = gGlobal->getFreshID("fSoundfile"); + string SFcache = varname + "ca"; + + addUIWidget(reverse(tl(path)), uiWidget(hd(path), tree(varname), sig)); + + pushDeclare(InstBuilder::genDecStructVar(varname, InstBuilder::genBasicTyped(Typed::kSound_ptr))); + + if (gGlobal->gUseDefaultSound) { + BlockInst* block = InstBuilder::genBlockInst(); + block->pushBackInst(InstBuilder::genStoreStructVar(varname, InstBuilder::genLoadGlobalVar("defaultsound"))); + + pushResetUIInstructions(InstBuilder::genIfInst( + InstBuilder::genEqual(InstBuilder::genCastInst(InstBuilder::genLoadStructVar(varname), + InstBuilder::genBasicTyped(Typed::kUint_ptr)), + InstBuilder::genTypedZero(Typed::kSound_ptr)), + block, InstBuilder::genBlockInst())); + } + + if (gGlobal->gOneSample >= 0) { + pushDeclare(InstBuilder::genDecStructVar(SFcache, InstBuilder::genBasicTyped(Typed::kSound_ptr))); + pushComputeBlockMethod(InstBuilder::genStoreStructVar(SFcache, InstBuilder::genLoadStructVar(varname))); + } else { + pushComputeBlockMethod(InstBuilder::genDecStackVar(SFcache, InstBuilder::genBasicTyped(Typed::kSound_ptr), + InstBuilder::genLoadStructVar(varname))); + } + + return InstBuilder::genLoadStructVar(varname); +} diff -Nru faust-2.50.6+ds0/compiler/generator/instructions_compiler_jax.hh faust-2.54.9+ds0/compiler/generator/instructions_compiler_jax.hh --- faust-2.50.6+ds0/compiler/generator/instructions_compiler_jax.hh 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/instructions_compiler_jax.hh 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,42 @@ +/************************************************************************ + ************************************************************************ + FAUST compiler + Copyright (C) 2017-2021 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., 675 Mass Ave, Cambridge, MA 02139, USA. + ************************************************************************ + ************************************************************************/ + +#ifndef _INSTRUCTION_COMPILER_JAX_H +#define _INSTRUCTION_COMPILER_JAX_H + +#include "instructions_compiler.hh" + +// To be used with JAX backend + +class InstructionsCompilerJAX : public InstructionsCompiler { + public: + InstructionsCompilerJAX(CodeContainer* container): InstructionsCompiler(container) + {} + + StatementInst* generateShiftArray(const string& vname, int delay) override; + + ValueInst* generateDelayLine(ValueInst* exp, Typed::VarType ctype, const string& vname, int mxd, + Address::AccessType& var_access, ValueInst* ccs) override; + + ValueInst* generateSoundfile(Tree sig, Tree path) override; +}; + +#endif diff -Nru faust-2.50.6+ds0/compiler/generator/instructions_complexity.hh faust-2.54.9+ds0/compiler/generator/instructions_complexity.hh --- faust-2.50.6+ds0/compiler/generator/instructions_complexity.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/instructions_complexity.hh 2022-12-17 10:41:42.000000000 +0000 @@ -75,7 +75,11 @@ DispatchVisitor::visit(inst); } - virtual void visit(LoadVarInst* inst) { fLoad++; } + virtual void visit(LoadVarInst* inst) + { + fLoad++; + DispatchVisitor::visit(inst); + } virtual void visit(StoreVarInst* inst) { fStore++; diff -Nru faust-2.50.6+ds0/compiler/generator/instructions.hh faust-2.54.9+ds0/compiler/generator/instructions.hh --- faust-2.50.6+ds0/compiler/generator/instructions.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/instructions.hh 2022-12-17 10:41:42.000000000 +0000 @@ -72,7 +72,7 @@ template struct ArrayNumInst; -// Numbers +// Numbers and array of numbers struct FloatNumInst; struct FloatArrayNumInst; struct Int32NumInst; @@ -94,6 +94,7 @@ // Selector struct Select2Inst; +// Null value struct NullValueInst; // =========== @@ -109,6 +110,7 @@ // Memory store struct StoreVarInst; +// Array move struct ShiftArrayVarInst; // Function call @@ -129,7 +131,10 @@ // Block of statements struct BlockInst; +// A no-op statement struct DropInst; + +// Null statement struct NullStatementInst; // ====== @@ -324,7 +329,9 @@ virtual void visit(VectorTyped* typed) {} }; +// ======================= // Clone a FIR expression +// ======================= struct CloneVisitor : public virtual Garbageable { CloneVisitor() {} diff -Nru faust-2.50.6+ds0/compiler/generator/interpreter/fbc_executor.hh faust-2.54.9+ds0/compiler/generator/interpreter/fbc_executor.hh --- faust-2.50.6+ds0/compiler/generator/interpreter/fbc_executor.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/interpreter/fbc_executor.hh 2022-12-17 10:41:42.000000000 +0000 @@ -52,7 +52,7 @@ virtual void updateInputControls() {} virtual void updateOutputControls() {} - virtual void dumpMemory(FBCBlockInstruction* block, const std::string& name, const std::string& filename) {} + virtual void dumpMemory(std::vector*> blocks, const std::string& name, const std::string& filename) {} }; diff -Nru faust-2.50.6+ds0/compiler/generator/interpreter/fbc_interpreter.hh faust-2.54.9+ds0/compiler/generator/interpreter/fbc_interpreter.hh --- faust-2.50.6+ds0/compiler/generator/interpreter/fbc_interpreter.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/interpreter/fbc_interpreter.hh 2022-12-17 10:41:42.000000000 +0000 @@ -283,10 +283,10 @@ if (TRACE >= 4) { if (std::isnan(val)) { - std::cout << "-------- Interpreter 'Nan' trace start --------" << std::endl; + std::cout << "-------- Interpreter 'NaN' trace start --------" << std::endl; traceInstruction(it); fTraceContext.write(&std::cout); - std::cout << "-------- Interpreter 'Nan' trace end --------\n\n"; + std::cout << "-------- Interpreter 'NaN' trace end --------\n\n"; // Fails at first error... if (TRACE == 4) { throw faustexception("Interpreter exit\n"); @@ -311,8 +311,8 @@ if (TRACE >= 4 && ((index < 0) || (index >= fIntHeap[fFactory->fCountOffset]))) { std::cout << "-------- Interpreter crash trace start --------" << std::endl; - std::cout << "assertAudioBuffer : count " << fIntHeap[fFactory->fCountOffset]; - std::cout << " index " << index << std::endl; + std::cout << "assertAudioBuffer : count = " << fIntHeap[fFactory->fCountOffset]; + std::cout << " index = " << index << std::endl; fTraceContext.write(&std::cout); std::cout << "-------- Interpreter crash trace end --------\n\n"; if (TRACE == 4) { @@ -324,18 +324,21 @@ inline int assertStoreIntHeap(InstructionIT it, int index, int size = -1) { + int index_in_array = index - (*it)->fOffset1; if (TRACE >= 4 && - ((index < 0) || (index >= fFactory->fIntHeapSize) || (size > 0 && (index >= ((*it)->fOffset1 + size))))) { + ((index < 0) + || (index >= fFactory->fIntHeapSize) + || (size > 0 && ((index_in_array < 0) || (index_in_array >= size))))) { std::cout << "-------- Interpreter crash trace start --------" << std::endl; if (size > 0) { - std::cout << "assertStoreIntHeap array: fIntHeapSize "; - std::cout << fFactory->fIntHeapSize << " index " << (index - (*it)->fOffset1); - std::cout << " size " << size; - std::cout << " name " << (*it)->fName << std::endl; + std::cout << "assertStoreIntHeap array: fIntHeapSize = "; + std::cout << fFactory->fIntHeapSize << " index = " << index_in_array; + std::cout << " size = " << size; + std::cout << " name = " << (*it)->fName << std::endl; } else { - std::cout << "assertStoreIntHeap scalar: fIntHeapSize "; - std::cout << fFactory->fIntHeapSize << " index " << index; - std::cout << " name " << (*it)->fName << std::endl; + std::cout << "assertStoreIntHeap scalar: fIntHeapSize = "; + std::cout << fFactory->fIntHeapSize << " index = " << index; + std::cout << " name = " << (*it)->fName << std::endl; } fTraceContext.write(&std::cout); std::cout << "-------- Interpreter crash trace end --------\n\n"; @@ -348,18 +351,21 @@ inline int assertStoreRealHeap(InstructionIT it, int index, int size = -1) { + int index_in_array = index - (*it)->fOffset1; if (TRACE >= 4 && - ((index < 0) || (index >= fFactory->fRealHeapSize) || (size > 0 && (index >= ((*it)->fOffset1 + size))))) { + ((index < 0) + || (index >= fFactory->fRealHeapSize) + || (size > 0 && ((index_in_array < 0) || (index_in_array >= size))))) { std::cout << "-------- Interpreter crash trace start --------" << std::endl; if (size > 0) { - std::cout << "assertStoreRealHeap array: fIntHeapSize "; - std::cout << fFactory->fRealHeapSize << " index " << (index - (*it)->fOffset1); - std::cout << " size " << size; - std::cout << " name " << (*it)->fName << std::endl; + std::cout << "assertStoreRealHeap array: fRealHeapSize = "; + std::cout << fFactory->fRealHeapSize << " index = " << index_in_array; + std::cout << " size = " << size; + std::cout << " name = " << (*it)->fName << std::endl; } else { - std::cout << "assertStoreRealHeap scalar: fIntHeapSize "; - std::cout << fFactory->fRealHeapSize << " index " << index; - std::cout << " name " << (*it)->fName << std::endl; + std::cout << "assertStoreRealHeap scalar: fRealHeapSize = "; + std::cout << fFactory->fRealHeapSize << " index = " << index; + std::cout << " name = " << (*it)->fName << std::endl; } fTraceContext.write(&std::cout); std::cout << "-------- Interpreter crash trace end --------\n\n"; @@ -372,22 +378,23 @@ inline int assertLoadIntHeap(InstructionIT it, int index, int size = -1) { + int index_in_array = index - (*it)->fOffset1; if ((TRACE >= 4) && ((index < 0) || (index >= fFactory->fIntHeapSize) - || (size > 0 && (index >= ((*it)->fOffset1 + size))) + || (size > 0 && ((index_in_array < 0) || (index_in_array >= size))) || (fIntHeap[index] == DUMMY_INT))) { std::cout << "-------- Interpreter crash trace start --------" << std::endl; if (size > 0) { - std::cout << "assertLoadIntHeap array: fIntHeapSize "; - std::cout << fFactory->fIntHeapSize << " index " << (index - (*it)->fOffset1); - std::cout << " size " << size; - if (index >= 0) std::cout << " value " << fIntHeap[index]; - std::cout << " name " << (*it)->fName << std::endl; + std::cout << "assertLoadIntHeap array: fIntHeapSize = "; + std::cout << fFactory->fIntHeapSize << " index = " << index_in_array; + std::cout << " size = " << size; + if (index >= 0) std::cout << " value = " << fIntHeap[index]; + std::cout << " name = " << (*it)->fName << std::endl; } else { - std::cout << "assertLoadIntHeap scalar: fIntHeapSize "; - std::cout << fFactory->fIntHeapSize << " index " << index; - std::cout << " name " << (*it)->fName << std::endl; + std::cout << "assertLoadIntHeap scalar: fIntHeapSize = "; + std::cout << fFactory->fIntHeapSize << " index = " << index; + std::cout << " name = " << (*it)->fName << std::endl; } fTraceContext.write(&std::cout); std::cout << "-------- Interpreter crash trace end --------\n\n"; @@ -400,22 +407,23 @@ inline int assertLoadRealHeap(InstructionIT it, int index, int size = -1) { + int index_in_array = index - (*it)->fOffset1; if ((TRACE >= 4) && ((index < 0) || (index >= fFactory->fRealHeapSize) - || (size > 0 && (index >= ((*it)->fOffset1 + size))) + || (size > 0 && ((index_in_array < 0) || (index_in_array >= size))) || (fRealHeap[index] == REAL(DUMMY_REAL)))) { std::cout << "-------- Interpreter crash trace start --------" << std::endl; if (size > 0) { - std::cout << "assertLoadRealHeap array: fRealHeapSize "; - std::cout << fFactory->fRealHeapSize << " index " << (index - (*it)->fOffset1); - std::cout << " size " << size; - if (index >= 0) std::cout << " value " << fRealHeap[index]; - std::cout << " name " << (*it)->fName << std::endl; + std::cout << "assertLoadRealHeap array: fRealHeapSize = "; + std::cout << fFactory->fRealHeapSize << " index = " << index_in_array; + std::cout << " size = " << size; + if (index >= 0) std::cout << " value = " << fRealHeap[index]; + std::cout << " name = " << (*it)->fName << std::endl; } else { - std::cout << "assertLoadRealHeap scalar: fRealHeapSize "; - std::cout << fFactory->fRealHeapSize << " index " << index; - std::cout << " name " << (*it)->fName << std::endl; + std::cout << "assertLoadRealHeap scalar: fRealHeapSize = "; + std::cout << fFactory->fRealHeapSize << " index = " << index; + std::cout << " name = " << (*it)->fName << std::endl; } fTraceContext.write(&std::cout); std::cout << "-------- Interpreter crash trace end --------\n\n"; @@ -426,20 +434,6 @@ return index; } - inline void assertIndex(InstructionIT it, int index, int size = -1) - { - if ((TRACE >= 4) && ((index < 0) || (index >= size))) { - std::cout << "-------- Interpreter crash trace start --------" << std::endl; - std::cout << "index " << index << " size " << size << std::endl; - traceInstruction(it); - fTraceContext.write(&std::cout); - throw faustexception("Interpreter exit\n"); - } - if (TRACE == 4 || TRACE == 7) { - throw faustexception("Interpreter exit\n"); - } - } - inline REAL checkReal(InstructionIT it, REAL val) { return (TRACE > 0) ? checkRealAux(it, val) : val; } void updateInputControls() @@ -809,8 +803,6 @@ case FBCInstruction::kLoadIndexedReal : { int offset = popInt(); if (TRACE > 0) { - // DEBUG - // assertIndex(it, offset, (*it)->fOffset2); pushReal(it, fRealHeap[assertLoadRealHeap(it, (*it)->fOffset1 + offset, (*it)->fOffset2)]); } else { pushReal(it, fRealHeap[(*it)->fOffset1 + offset]); @@ -821,8 +813,6 @@ case FBCInstruction::kLoadIndexedInt : { int offset = popInt(); if (TRACE > 0) { - // DEBUG - // assertIndex(it, offset, (*it)->fOffset2); pushInt(fIntHeap[assertLoadIntHeap(it, (*it)->fOffset1 + offset, (*it)->fOffset2)]); } else { pushInt(fIntHeap[(*it)->fOffset1 + offset]); @@ -833,8 +823,6 @@ case FBCInstruction::kStoreIndexedReal : { int offset = popInt(); if (TRACE > 0) { - // DEBUG - // assertIndex(it, offset, (*it)->fOffset2); fRealHeap[assertStoreRealHeap(it, (*it)->fOffset1 + offset, (*it)->fOffset2)] = popReal(it); } else { fRealHeap[(*it)->fOffset1 + offset] = popReal(it); @@ -845,8 +833,6 @@ case FBCInstruction::kStoreIndexedInt : { int offset = popInt(); if (TRACE > 0) { - // DEBUG - // assertIndex(it, offset, (*it)->fOffset2); fIntHeap[assertStoreIntHeap(it, (*it)->fOffset1 + offset, (*it)->fOffset2)] = popInt(); } else { fIntHeap[(*it)->fOffset1 + offset] = popInt(); @@ -2884,8 +2870,6 @@ do_kLoadIndexedInt : { int offset = popInt(); if (TRACE > 0) { - // DEBUG - // assertIndex(it, offset, (*it)->fOffset2); pushInt(fIntHeap[assertLoadIntHeap(it, (*it)->fOffset1 + offset, (*it)->fOffset2)]); } else { pushInt(fIntHeap[(*it)->fOffset1 + offset]); @@ -2896,8 +2880,6 @@ do_kStoreIndexedReal : { int offset = popInt(); if (TRACE > 0) { - // DEBUG - // assertIndex(it, offset, (*it)->fOffset2); fRealHeap[assertStoreRealHeap(it, (*it)->fOffset1 + offset, (*it)->fOffset2)] = popReal(it); } else { fRealHeap[(*it)->fOffset1 + offset] = popReal(it); @@ -2908,8 +2890,6 @@ do_kStoreIndexedInt : { int offset = popInt(); if (TRACE > 0) { - // DEBUG - // assertIndex(it, offset, (*it)->fOffset2); fIntHeap[assertStoreIntHeap(it, (*it)->fOffset1 + offset, (*it)->fOffset2)] = popInt(); } else { fIntHeap[(*it)->fOffset1 + offset] = popInt(); @@ -4720,20 +4700,79 @@ printStats(); } } + + inline bool startWith(const std::string& str, const std::string& prefix) + { + return (str.substr(0, prefix.size()) == prefix); + } + + void buildMemoryMap(FBCBlockInstruction* block, + std::map>& memory_map, + std::vector mem_opcodes) + { + if (!block) return; + for (const auto& it : block->fInstructions) { + for (const auto& mem_opcode : mem_opcodes) { + if (startWith(gFBCInstructionTable[it->fOpcode], mem_opcode)) { + memory_map[it->fOffset1] = std::make_pair(it->fOffset2, it->fName); + break; + } + } + buildMemoryMap(it->getBranch1(), memory_map, mem_opcodes); + buildMemoryMap(it->getBranch2(), memory_map, mem_opcodes); + } + } - void dumpMemory(FBCBlockInstruction* block, const std::string& name, const std::string& filename) + void dumpMemory(std::vector*> blocks, + const std::string& name, + const std::string& filename) { std::ofstream out(filename); out << "DSP name: " << name << std::endl; - - out << "REAL memory: " << fFactory->fRealHeapSize << "\n"; - for (int i = 0; i < fFactory->fRealHeapSize; i++) { - out << "mem: " < memory_map_real; + for (const auto& it : blocks) { + buildMemoryMap(it, memory_map_real, {"kLoadReal", "kStoreReal", "kLoadIndexedReal", "kStoreIndexedReal"}); + } + out << "=================================" << std::endl; + out << "REAL memory: " << fFactory->fRealHeapSize << std::endl; + for (int i = 0; i < fFactory->fRealHeapSize;) { + //out << "mem: " < 0) { + // Array + int j = 0; + for (j = 0; j < memory_map_real[i].first; j++) { + out << i+j << " " << memory_map_real[i].second << "[" << j << "] " << fRealHeap[i+j] << std::endl; + } + i += j; + } else { + // Scalar + out <fIntHeapSize << "\n"; - for (int i = 0; i < fFactory->fIntHeapSize; i++) { - out << "mem: " < memory_map_int; + for (const auto& it : blocks) { + buildMemoryMap(it, memory_map_int, {"kLoadInt", "kStoreInt", "kLoadIndexedInt", "kStoreIndexedInts"}); + } + out << "=================================" << std::endl; + out << "INT memory: " << fFactory->fIntHeapSize << std::endl; + for (int i = 0; i < fFactory->fIntHeapSize;) { + if (memory_map_int[i].first > 0) { + // Array + int j = 0; + for (j = 0; j < memory_map_int[i].first; j++) { + out << i+j << " " << memory_map_int[i].second << "[" << j << "] " << fIntHeap[i+j] << std::endl; + } + i += j; + } else { + // Scalar + out << i << " " << memory_map_int[i].second << " " << fIntHeap[i] << std::endl; + i++; + } } } diff -Nru faust-2.50.6+ds0/compiler/generator/interpreter/interpreter_dsp_aux.hh faust-2.54.9+ds0/compiler/generator/interpreter/interpreter_dsp_aux.hh --- faust-2.50.6+ds0/compiler/generator/interpreter/interpreter_dsp_aux.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/interpreter/interpreter_dsp_aux.hh 2022-12-17 10:41:42.000000000 +0000 @@ -730,7 +730,15 @@ } catch (faustexception& e) { std::cerr << e.Message(); - fFBCExecutor->dumpMemory(fFactory->fComputeDSPBlock, + std::vector*> blocks = { + fFactory->fStaticInitBlock, + fFactory->fInitBlock, + fFactory->fResetUIBlock, + fFactory->fClearBlock, + fFactory->fComputeBlock, + fFactory->fComputeDSPBlock + }; + fFBCExecutor->dumpMemory(blocks, fFactory->getName(), "DumpMem-" + fFactory->getName() + std::to_string(fCycle) + ".txt"); std::ofstream code_out("DumpCode-" + fFactory->getName() + ".txt"); @@ -740,7 +748,16 @@ } if ((TRACE == 7) && (fCycle < 4)) { - fFBCExecutor->dumpMemory(fFactory->fComputeDSPBlock, fFactory->getName(), + std::vector*> blocks = { + fFactory->fStaticInitBlock, + fFactory->fInitBlock, + fFactory->fResetUIBlock, + fFactory->fClearBlock, + fFactory->fComputeBlock, + fFactory->fComputeDSPBlock + }; + fFBCExecutor->dumpMemory(blocks, + fFactory->getName(), "DumpMem-" + fFactory->getName() + std::to_string(fCycle) + ".txt"); } @@ -873,6 +890,8 @@ void setDSPCode(std::string code) { fFactory->setDSPCode(code); } std::string getCompileOptions() { return fFactory->getCompileOptions(); } + + std::vector getWarningMessages() { return fFactory->getWarningMessages(); } interpreter_dsp* createDSPInstance(); diff -Nru faust-2.50.6+ds0/compiler/generator/interpreter/interpreter_dynamic_dsp_aux.cpp faust-2.54.9+ds0/compiler/generator/interpreter/interpreter_dynamic_dsp_aux.cpp --- faust-2.50.6+ds0/compiler/generator/interpreter/interpreter_dynamic_dsp_aux.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/interpreter/interpreter_dynamic_dsp_aux.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -77,7 +77,7 @@ } argv1[argc1] = nullptr; // NULL terminated argv - dsp_factory_base* dsp_factory_aux = createFactory(name_app.c_str(), dsp_content.c_str(), argc1, argv1, error_msg, true); + dsp_factory_base* dsp_factory_aux = createFactory(name_app, dsp_content, argc1, argv1, error_msg, true); if (dsp_factory_aux) { dsp_factory_aux->setName(name_app); interpreter_dsp_factory* factory = new interpreter_dsp_factory(dsp_factory_aux); @@ -114,7 +114,7 @@ } argv1[argc1] = nullptr; // NULL terminated argv - dsp_factory_base* dsp_factory_aux = createFactory(name_app.c_str(), signals, argc1, argv1, error_msg); + dsp_factory_base* dsp_factory_aux = createFactory(name_app, signals, argc1, argv1, error_msg); if (dsp_factory_aux) { dsp_factory_aux->setName(name_app); interpreter_dsp_factory* factory = new interpreter_dsp_factory(dsp_factory_aux); diff -Nru faust-2.50.6+ds0/compiler/generator/jax/jax_code_container.cpp faust-2.54.9+ds0/compiler/generator/jax/jax_code_container.cpp --- faust-2.50.6+ds0/compiler/generator/jax/jax_code_container.cpp 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/jax/jax_code_container.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,287 @@ +/************************************************************************ + ************************************************************************ + FAUST compiler + Copyright (C) 2021 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 General Public License as published by + the Free Software Foundation; either version 2 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, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + ************************************************************************ + ************************************************************************/ + +#include "jax_code_container.hh" +#include "Text.hh" +#include "exception.hh" +#include "fir_function_builder.hh" +#include "floats.hh" +#include "global.hh" + +using namespace std; + +/* + JAX backend and module description: + + - Whereas a normal code container would generate a "compute" method, we generate + a one-sample loop "tick" method. Our hard-coded "compute" method __call__ is implemented + in an architecture file. It uses JAX's scan function in conjunction with the generated tick function. + - Inside "__call__" and before using "scan", we setup the arrays, soundfiles, user interface parameters, + and other state variables. + - One tricky part of JAX is modifying arrays in-place: + https://jax.readthedocs.io/en/latest/_autosummary/jax.numpy.ndarray.at.html + Whereas C++ would look like + `fRec1[0] = fTemp0` + in JAX we have to do + `state["fRec1"] = state["fRec1"].at[0].set(fTemp0)` + Also, this at-and-set operation is slow, so we only use it inside the tick method. + This is why in all other places (like initializing sound files which are arrays), + we use numpy arrays instead of jnp arrays. It's best to just look at the generated code and notice + how the jnp prefix is used differently than the np prefix. + - In order to simplify global array typing, subcontainers are actually merged in the main DSP structure: + - so 'mergeSubContainers' is used + - global variables are added in the DSP structure + - the JAXInitFieldsVisitor class does initialisation for waveforms. This makes it easy to use numpy + instead of jax when initializing arrays (good for speed). We also use fUseNumpy in this decision making. + We convert the numpy arrays to jax numpy before they're used in the tick method. + - the fGlobalDeclarationInstructions contains global functions and variables. It is "manually" used + to generate global functions and move global variables declaration at DSP structure level. +*/ + +map JAXInstVisitor::gFunctionSymbolTable; + +dsp_factory_base* JAXCodeContainer::produceFactory() +{ + return new text_dsp_factory_aux( + fKlassName, "", "", + ((dynamic_cast(fOut)) ? dynamic_cast(fOut)->str() : ""), ""); +} + +JAXCodeContainer::JAXCodeContainer(const std::string& name, int numInputs, int numOutputs, std::ostream* out) +{ + // Mandatory + initialize(numInputs, numOutputs); + fKlassName = name; + fOut = out; + + // Allocate one static visitor + if (!gGlobal->gJAXVisitor) { + gGlobal->gJAXVisitor = new JAXInstVisitor(out, name); + } +} + +CodeContainer* JAXCodeContainer::createScalarContainer(const string& name, int sub_container_type) +{ + return new JAXScalarCodeContainer(name, 0, 1, fOut, sub_container_type); +} + +CodeContainer* JAXCodeContainer::createContainer(const string& name, int numInputs, int numOutputs, ostream* dst) +{ + gGlobal->gDSPStruct = true; + CodeContainer* container; + + if (gGlobal->gOpenCLSwitch) { + throw faustexception("ERROR : OpenCL not supported for JAX\n"); + } + if (gGlobal->gCUDASwitch) { + throw faustexception("ERROR : CUDA not supported for JAX\n"); + } + + if (gGlobal->gOpenMPSwitch) { + throw faustexception("ERROR : OpenMP not supported for JAX\n"); + } else if (gGlobal->gSchedulerSwitch) { + throw faustexception("ERROR : Scheduler not supported for JAX\n"); + } else if (gGlobal->gVectorSwitch) { + throw faustexception("ERROR : Vector not supported for JAX\n"); + } else { + container = new JAXScalarCodeContainer(name, numInputs, numOutputs, dst, kInt); + } + + return container; +} + +inline string flattenJSONforPython(const string& src) +{ + string dst; + for (size_t i = 0; i < src.size(); i++) { + switch (src[i]) { + case '"': + dst += "\\\""; + break; + case '\\': + dst += "/"; + break; + case '\'': + dst += "'"; + break; + default: + dst += src[i]; + break; + } + } + return dst; +} + +void JAXCodeContainer::produceClass() +{ + int n = 0; + + // Print header + *fOut << "\"\"\"" << endl + << "Code generated with Faust version " << FAUSTVERSION << endl; + *fOut << "Compilation options: "; + stringstream stream; + gGlobal->printCompilationOptions(stream); + *fOut << stream.str(); + tab(n, *fOut); + *fOut << "\"\"\""; + tab(n, *fOut); + + if (gGlobal->gFloatSize == 2) { + tab(n, *fOut); + *fOut << "# enable double precision: https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision"; + tab(n, *fOut); + *fOut << "from jax.config import config"; + tab(n, *fOut); + *fOut << "config.update(\"jax_enable_x64\", True)"; + tab(n, *fOut); + *fOut << "FAUSTFLOAT = jnp.float64"; + tab(n, *fOut); + } else { + tab(n, *fOut); + *fOut << "# enable single precision"; + tab(n, *fOut); + *fOut << "FAUSTFLOAT = jnp.float32"; + tab(n, *fOut); + } + + // Merge sub containers + mergeSubContainers(); + + // Functions + tab(n, *fOut); + gGlobal->gJAXVisitor->Tab(n); + + *fOut << "class " << fKlassName << "(nn.Module):"; + tab(n + 1, *fOut); + + // Fields + gGlobal->gJAXVisitor->Tab(n + 1); + + tab(n + 1, *fOut); + *fOut << "sample_rate: int"; + + tab(n + 1, *fOut); + gGlobal->gJAXVisitor->Tab(n); + + tab(n + 1, *fOut); + produceInfoFunctions(n + 1, "", "self", false, FunTyped::kDefault, gGlobal->gJAXVisitor); + + *fOut << "def initialize(self, sample_rate, x, T):"; + { + tab(n + 2, *fOut); + *fOut << "state = {}"; + tab(n + 2, *fOut); + tab(n + 2, *fOut); + *fOut << "# global declarations:"; + JAXInitFieldsVisitor initializer(fOut, n + 2); + generateDeclarations(&initializer); + // Generate global variables initialisation + for (const auto& it : fGlobalDeclarationInstructions->fCode) { + if (dynamic_cast(it)) { + it->accept(&initializer); + } + } + tab(n + 2, *fOut); + tab(n + 2, *fOut); + *fOut << "# init constants:"; + tab(n + 2, *fOut); + gGlobal->gJAXVisitor->Tab(n + 2); + inlineSubcontainersFunCalls(fInitInstructions)->accept(gGlobal->gJAXVisitor); + tab(n + 2, *fOut); + *fOut << "# inline subcontainers:"; + tab(n + 2, *fOut); + gGlobal->gJAXVisitor->Tab(n + 2); + inlineSubcontainersFunCalls(fStaticInitInstructions)->accept(gGlobal->gJAXVisitor); + tab(n + 2, *fOut); + *fOut << "# instance clear:"; + tab(n + 2, *fOut); + generateClear(gGlobal->gJAXVisitor); + tab(n + 2, *fOut); + *fOut << "return state"; + tab(n + 1, *fOut); + } + back(1, *fOut); + + // JSON generation + tab(n+1, *fOut); + *fOut << "def getJSON(self):"; + { + string json; + if (gGlobal->gFloatSize == 1) { + json = generateJSON(); + } else { + json = generateJSON(); + } + tab(n + 2, *fOut); + *fOut << "json_str = \"\"\"" << flattenJSONforPython(json) << "\"\"\""; + tab(n + 2, *fOut); + *fOut << "return json.loads(json_str)"; + tab(n + 1, *fOut); + } + + // User interface + tab(n + 1, *fOut); + *fOut << "def build_interface(self, state, x, T: int):"; + tab(n + 2, *fOut); + *fOut << "ui_path = []"; + tab(n + 2, *fOut); + gGlobal->gJAXVisitor->Tab(n + 2); + generateUserInterface(gGlobal->gJAXVisitor); + tab(n + 2, *fOut); + *fOut << "return state"; + + // Compute + tab(n + 1, *fOut); + generateCompute(n+1); + tab(n, *fOut); +} + +void JAXCodeContainer::generateCompute(int n) +{ + // Generates declaration + tab(n, *fOut); + *fOut << "@staticmethod"; + tab(n, *fOut); + *fOut << "def tick(state: dict, inputs: jnp.array):"; + tab(n + 1, *fOut); + + tab(n + 1, *fOut); + gGlobal->gJAXVisitor->Tab(n + 1); + + // Generates local variables declaration and setup + gGlobal->gJAXVisitor->fUseNumpy = false; + generateComputeBlock(gGlobal->gJAXVisitor); + + auto loop = fCurLoop->generateOneSample(); + loop->accept(gGlobal->gJAXVisitor); + + generatePostComputeBlock(gGlobal->gJAXVisitor); + gGlobal->gJAXVisitor->fUseNumpy = true; +} + +// Scalar +JAXScalarCodeContainer::JAXScalarCodeContainer(const string& name, int numInputs, int numOutputs, std::ostream* out, + int sub_container_type) + : JAXCodeContainer(name, numInputs, numOutputs, out) +{ + fSubContainerType = sub_container_type; +} diff -Nru faust-2.50.6+ds0/compiler/generator/jax/jax_code_container.hh faust-2.54.9+ds0/compiler/generator/jax/jax_code_container.hh --- faust-2.50.6+ds0/compiler/generator/jax/jax_code_container.hh 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/jax/jax_code_container.hh 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,84 @@ +/************************************************************************ + ************************************************************************ + FAUST compiler + Copyright (C) 2021 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 General Public License as published by + the Free Software Foundation; either version 2 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, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + ************************************************************************ + ************************************************************************/ + +#ifndef _JAX_CODE_CONTAINER_H +#define _JAX_CODE_CONTAINER_H + +#include "jax_instructions.hh" +#include "code_container.hh" +#include "dsp_factory.hh" +#include "omp_code_container.hh" +#include "vec_code_container.hh" +#include "wss_code_container.hh" + +#ifdef WIN32 +#pragma warning(disable : 4250) +#endif + +class JAXCodeContainer : public virtual CodeContainer { + protected: + static JAXInstVisitor* gJAXVisitor; + std::ostream* fOut; + + virtual void produceClass(); + + // Not used + virtual void produceInternal() {} + + void generateCompute(int n); + + public: + JAXCodeContainer() + {} + JAXCodeContainer(const std::string& name, int numInputs, int numOutputs, std::ostream* out); + + virtual ~JAXCodeContainer() + { + // fCodeProducer is a 'Garbageable' + } + + virtual dsp_factory_base* produceFactory(); + + CodeContainer* createScalarContainer(const std::string& name, int sub_container_type); + + static CodeContainer* createContainer(const std::string& name, int numInputs, int numOutputs, + std::ostream* dst = new std::stringstream()); + + BlockInst* get_fComputeBlockInstructions() { return fComputeBlockInstructions; } +}; + +class JAXScalarCodeContainer : public JAXCodeContainer { + protected: + + public: + JAXScalarCodeContainer() + {} + JAXScalarCodeContainer(const std::string& name, + int numInputs, + int numOutputs, + std::ostream* out, + int sub_container_type); + virtual ~JAXScalarCodeContainer() + {} + +}; + +#endif diff -Nru faust-2.50.6+ds0/compiler/generator/jax/jax_instructions.hh faust-2.54.9+ds0/compiler/generator/jax/jax_instructions.hh --- faust-2.50.6+ds0/compiler/generator/jax/jax_instructions.hh 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/jax/jax_instructions.hh 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,808 @@ +/************************************************************************ + ************************************************************************ + FAUST compiler + Copyright (C) 2021 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 General Public License as published by + the Free Software Foundation; either version 2 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, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + ************************************************************************ + ************************************************************************/ + +#ifndef _JAX_INSTRUCTIONS_H +#define _JAX_INSTRUCTIONS_H + +#include + +#include "text_instructions.hh" +#include "struct_manager.hh" + +using namespace std; + +// Visitor used to initialize array fields into the DSP structure +struct JAXInitFieldsVisitor : public DispatchVisitor { + std::ostream* fOut; + int fTab; + + JAXInitFieldsVisitor(std::ostream* out, int tab = 0) : fOut(out), fTab(tab) {} + + virtual void visit(DeclareVarInst* inst) + { + ArrayTyped* array_type = dynamic_cast(inst->fType); + if (array_type) { + tab(fTab, *fOut); + inst->fAddress->accept(this); + *fOut << " = "; + if (inst->fValue) { + inst->fValue->accept(this); + } else { + ZeroInitializer(fOut, inst->fType); + } + } + } + + virtual void visit(NamedAddress* named) + { + // kStaticStruct are actually merged in the main DSP + if (named->getAccess() & Address::kStruct || named->getAccess() & Address::kStaticStruct) { + *fOut << "state[\""; + } + *fOut << named->fName; + if (named->getAccess() & Address::kStruct || named->getAccess() & Address::kStaticStruct) { + *fOut << "\"]"; + } + } + + static void ZeroInitializer(std::ostream* fOut, Typed* typed) + { + ArrayTyped* array_type = dynamic_cast(typed); + faustassert(array_type); + if (isIntPtrType(typed->getType())) { + *fOut << "np.zeros((" << array_type->fSize << ",), dtype=np.int32)"; + } else if (isFloatType(typed->getType())) { + *fOut << "np.zeros((" << array_type->fSize << ",), dtype=np.float32)"; + } else { + *fOut << "np.zeros((" << array_type->fSize << ",), dtype=np.float64)"; + } + } + + // Needed for waveforms + virtual void visit(Int32ArrayNumInst* inst) + { + *fOut << "np.array("; + char sep = '['; + for (size_t i = 0; i < inst->fNumTable.size(); i++) { + *fOut << sep << inst->fNumTable[i]; + sep = ','; + } + *fOut << "], dtype=np.int32)"; + } + + virtual void visit(FloatArrayNumInst* inst) + { + *fOut << "np.array("; + char sep = '['; + for (size_t i = 0; i < inst->fNumTable.size(); i++) { + *fOut << sep << checkFloat(inst->fNumTable[i]); + sep = ','; + } + *fOut << "], dtype=np.float32)"; + } + + virtual void visit(DoubleArrayNumInst* inst) + { + *fOut << "np.array("; + char sep = '['; + for (size_t i = 0; i < inst->fNumTable.size(); i++) { + *fOut << sep << checkDouble(inst->fNumTable[i]); + sep = ','; + } + *fOut << "], dtype=np.float64)"; + } +}; + +class JAXInstVisitor : public TextInstVisitor { + private: + + /* + Global functions names table as a static variable in the visitor + so that each function prototype is generated as most once in the module. + */ + static map gFunctionSymbolTable; + + // Polymorphic math functions + map gPolyMathLibTable; + + // bool for "is storing left-hand-side". + // Suppose the output code will be `state['foo'] = bar`. + // This boolean indicates that we are starting this line but haven't yet reached the equals sign. + bool fIsStoringLhs = false; + + // bool for "will set array". + // jax has a special syntax for setting items of arrays: + // https://jax.readthedocs.io/en/latest/_autosummary/jax.numpy.ndarray.at.html + // This bool helps us know that we're going to use the .at[X] operator followed by the set(Y) operator. + // This bool is used in tandem with fIsStoringLhs. + bool fWillSetArray = false; + + // This bool is not related to fIsStoringLhs or fWillSetArray. + // It is used so that we don't cast to integers in the condition of a while (cond) loop. + bool fIsDoingWhile = false; + + std::set fLogSet; // set of widget zone having a log UI scale + std::set fExpSet; // set of widget zone having an exp UI scale + + public: + using TextInstVisitor::visit; + + // This bool indicates that we should use the numpy functions, so the prefix "np." + // If false, use jax.numpy "jnp." + // We want to use numpy when initializing arrays and sound files because it's faster than JAX. + bool fUseNumpy = true; + + JAXInstVisitor(std::ostream* out, const string& struct_name, int tab = 0) + : TextInstVisitor(out, ".", new JAXStringTypeManager(xfloat(), "*", struct_name), tab) + { + // Mark all math.h functions as generated... + gFunctionSymbolTable["abs"] = true; + + gFunctionSymbolTable["max_i"] = true; + gFunctionSymbolTable["min_i"] = true; + + gFunctionSymbolTable["max_f"] = true; + gFunctionSymbolTable["min_f"] = true; + + gFunctionSymbolTable["max_"] = true; + gFunctionSymbolTable["min_"] = true; + + gFunctionSymbolTable["max_l"] = true; + gFunctionSymbolTable["min_l"] = true; + + // Float version + gFunctionSymbolTable["fabsf"] = true; + gFunctionSymbolTable["acosf"] = true; + gFunctionSymbolTable["asinf"] = true; + gFunctionSymbolTable["atanf"] = true; + gFunctionSymbolTable["atan2f"] = true; + gFunctionSymbolTable["ceilf"] = true; + gFunctionSymbolTable["cosf"] = true; + gFunctionSymbolTable["expf"] = true; + gFunctionSymbolTable["exp10f"] = false; + gFunctionSymbolTable["floorf"] = true; + gFunctionSymbolTable["fmodf"] = true; + gFunctionSymbolTable["logf"] = true; + gFunctionSymbolTable["log10f"] = true; + gFunctionSymbolTable["powf"] = true; + gFunctionSymbolTable["remainderf"] = true; + gFunctionSymbolTable["rintf"] = true; + gFunctionSymbolTable["roundf"] = true; + gFunctionSymbolTable["sinf"] = true; + gFunctionSymbolTable["sqrtf"] = true; + gFunctionSymbolTable["tanf"] = true; + + // Hyperbolic + gFunctionSymbolTable["acoshf"] = true; + gFunctionSymbolTable["asinhf"] = true; + gFunctionSymbolTable["atanhf"] = true; + gFunctionSymbolTable["coshf"] = true; + gFunctionSymbolTable["sinhf"] = true; + gFunctionSymbolTable["tanhf"] = true; + + // Double version + gFunctionSymbolTable["fabs"] = true; + gFunctionSymbolTable["acos"] = true; + gFunctionSymbolTable["asin"] = true; + gFunctionSymbolTable["atan"] = true; + gFunctionSymbolTable["atan2"] = true; + gFunctionSymbolTable["ceil"] = true; + gFunctionSymbolTable["cos"] = true; + gFunctionSymbolTable["exp"] = true; + gFunctionSymbolTable["exp10"] = false; + gFunctionSymbolTable["floor"] = true; + gFunctionSymbolTable["fmod"] = true; + gFunctionSymbolTable["log"] = true; + gFunctionSymbolTable["log10"] = true; + gFunctionSymbolTable["pow"] = true; + gFunctionSymbolTable["remainder"] = true; + gFunctionSymbolTable["rint"] = true; + gFunctionSymbolTable["round"] = true; + gFunctionSymbolTable["sin"] = true; + gFunctionSymbolTable["sqrt"] = true; + gFunctionSymbolTable["tan"] = true; + + // Hyperbolic + gFunctionSymbolTable["acosh"] = true; + gFunctionSymbolTable["asinh"] = true; + gFunctionSymbolTable["atanh"] = true; + gFunctionSymbolTable["coshf"] = true; + gFunctionSymbolTable["sinh"] = true; + gFunctionSymbolTable["tanh"] = true; + + // Quad version + gFunctionSymbolTable["fabsl"] = true; + gFunctionSymbolTable["acosl"] = true; + gFunctionSymbolTable["asinl"] = true; + gFunctionSymbolTable["atanl"] = true; + gFunctionSymbolTable["atan2l"] = true; + gFunctionSymbolTable["ceill"] = true; + gFunctionSymbolTable["cosl"] = true; + gFunctionSymbolTable["expl"] = true; + gFunctionSymbolTable["exp10l"] = false; + gFunctionSymbolTable["floorl"] = true; + gFunctionSymbolTable["fmodl"] = true; + gFunctionSymbolTable["logl"] = true; + gFunctionSymbolTable["log10l"] = true; + gFunctionSymbolTable["powl"] = true; + gFunctionSymbolTable["remainderl"] = true; + gFunctionSymbolTable["rintl"] = true; + gFunctionSymbolTable["roundl"] = true; + gFunctionSymbolTable["sinl"] = true; + gFunctionSymbolTable["sqrtl"] = true; + gFunctionSymbolTable["tanl"] = true; + + // Hyperbolic + gFunctionSymbolTable["acoshl"] = true; + gFunctionSymbolTable["asinhl"] = true; + gFunctionSymbolTable["atanhl"] = true; + gFunctionSymbolTable["coshl"] = true; + gFunctionSymbolTable["sinhl"] = true; + gFunctionSymbolTable["tanhl"] = true; + + // Polymath mapping int version + gPolyMathLibTable["abs"] = "jnp.abs"; + gPolyMathLibTable["max_i"] = "jnp.maximum"; + gPolyMathLibTable["min_i"] = "jnp.minimum"; + + // Polymath mapping float version + gPolyMathLibTable["max_f"] = "jnp.maximum"; + gPolyMathLibTable["min_f"] = "jnp.minimum"; + + gPolyMathLibTable["fabsf"] = "jnp.abs"; + gPolyMathLibTable["acosf"] = "jnp.arccos"; + gPolyMathLibTable["asinf"] = "jnp.arcsin"; + gPolyMathLibTable["atanf"] = "jnp.arctan"; + gPolyMathLibTable["atan2f"] = "jnp.arctan2"; + gPolyMathLibTable["ceilf"] = "jnp.ceil"; + gPolyMathLibTable["cosf"] = "jnp.cos"; + gPolyMathLibTable["expf"] = "jnp.exp"; + gPolyMathLibTable["exp2f"] = "jnp.exp2"; + gPolyMathLibTable["exp10f"] = "jnp.exp10f"; + gPolyMathLibTable["floorf"] = "jnp.floor"; + gPolyMathLibTable["fmodf"] = "jnp.mod"; + gPolyMathLibTable["logf"] = "jnp.log"; + gPolyMathLibTable["log2f"] = "jnp.log2"; + gPolyMathLibTable["log10f"] = "jnp.log10"; + gPolyMathLibTable["powf"] = "jnp.power"; + gPolyMathLibTable["remainderf"] = "remainder"; // todo: we currently rely on a custom remainder implementation in the architecture file. + gPolyMathLibTable["rintf"] = "jnp.rint"; + gPolyMathLibTable["roundf"] = "jnp.round"; + gPolyMathLibTable["sinf"] = "jnp.sin"; + gPolyMathLibTable["sqrtf"] = "jnp.sqrt"; + gPolyMathLibTable["tanf"] = "jnp.tan"; + + // Hyperbolic + gPolyMathLibTable["acoshf"] = "jnp.arccosh"; + gPolyMathLibTable["asinhf"] = "jnp.arcsinh"; + gPolyMathLibTable["atanhf"] = "jnp.arctanh"; + gPolyMathLibTable["coshf"] = "jnp.cosh"; + gPolyMathLibTable["sinhf"] = "jnp.sinh"; + gPolyMathLibTable["tanhf"] = "jnp.tanh"; + + gPolyMathLibTable["isnanf"] = "jnp.isnan"; + gPolyMathLibTable["isinff"] = "jnp.isinf"; + gPolyMathLibTable["copysignf"] = "jnp.copysign"; + + // Polymath mapping double version + gPolyMathLibTable["max_"] = "jnp.maximum"; + gPolyMathLibTable["min_"] = "jnp.minimum"; + + gPolyMathLibTable["fabs"] = "jnp.abs"; + gPolyMathLibTable["acos"] = "jnp.arccos"; + gPolyMathLibTable["asin"] = "jnp.arcsin"; + gPolyMathLibTable["atan"] = "jnp.arctan"; + gPolyMathLibTable["atan2"] = "jnp.arctan2"; + gPolyMathLibTable["ceil"] = "jnp.ceil"; + gPolyMathLibTable["cos"] = "jnp.cos"; + gPolyMathLibTable["exp"] = "jnp.exp"; + gPolyMathLibTable["exp2"] = "jnp.exp2"; + gPolyMathLibTable["exp10"] = "jnp.exp10"; + gPolyMathLibTable["floor"] = "jnp.floor"; + gPolyMathLibTable["fmod"] = "jnp.mod"; + gPolyMathLibTable["log"] = "jnp.log"; + gPolyMathLibTable["log2"] = "jnp.log2"; + gPolyMathLibTable["log10"] = "jnp.log10"; + gPolyMathLibTable["pow"] = "jnp.power"; + gPolyMathLibTable["remainder"] = "remainder"; // todo: we currently rely on a custom remainder implementation in the architecture file. + gPolyMathLibTable["rint"] = "jnp.rint"; + gPolyMathLibTable["round"] = "jnp.round"; + gPolyMathLibTable["sin"] = "jnp.sin"; + gPolyMathLibTable["sqrt"] = "jnp.sqrt"; + gPolyMathLibTable["tan"] = "jnp.tan"; + + // Hyperbolic + gPolyMathLibTable["acosh"] = "jnp.arccosh"; + gPolyMathLibTable["asinh"] = "jnp.arcsinh"; + gPolyMathLibTable["atanh"] = "jnp.arctanh"; + gPolyMathLibTable["cosh"] = "jnp.cosh"; + gPolyMathLibTable["sinh"] = "jnp.sinh"; + gPolyMathLibTable["tanh"] = "jnp.tanh"; + + gPolyMathLibTable["isnan"] = "jnp.isnan"; + gPolyMathLibTable["isinf"] = "jnp.isinf"; + gPolyMathLibTable["copysign"] = "jnp.copysign"; + } + + virtual ~JAXInstVisitor() {} + + virtual void visit(AddMetaDeclareInst* inst) + { + if (inst->fKey == "scale") { + if (inst->fValue == "exp") { + fExpSet.emplace(inst->fZone); + } else if (inst->fValue == "log") { + fLogSet.emplace(inst->fZone); + } else { + // it's linear by default + } + } + } + + virtual void visit(OpenboxInst* inst) + { + *fOut << "ui_path.append(" << quote(inst->fName) << ")"; + EndLine(' '); + } + + virtual void visit(CloseboxInst* inst) + { + *fOut << "ui_path.pop()"; + tab(fTab, *fOut); + } + + virtual void visit(AddButtonInst* inst) + { + *fOut << "self.add_button(state, " << quote(inst->fZone) << ", ui_path," << quote(inst->fLabel) << ")"; + EndLine(' '); + } + + virtual void visit(AddSliderInst* inst) + { + std::string scaleMode = ""; + if (fExpSet.count(inst->fZone)) { + scaleMode = "\"exp\""; + } else if (fLogSet.count(inst->fZone)) { + scaleMode = "\"log\""; + } else { + scaleMode = "\"linear\""; + } + + switch (inst->fType) { + case AddSliderInst::kHorizontal: + case AddSliderInst::kVertical: + // clang-format off + *fOut << "self.add_slider(state, " + << quote(inst->fZone) << ", ui_path, " + << quote(inst->fLabel) << ", " + << checkReal(inst->fInit) << ", " + << checkReal(inst->fMin) << ", " + << checkReal(inst->fMax) << ", " + << scaleMode << ")"; + break; + // clang-format on + case AddSliderInst::kNumEntry: + // clang-format off + *fOut << "self.add_nentry(state, " + << quote(inst->fZone) << ", ui_path, " + << quote(inst->fLabel) << ", " + << checkReal(inst->fInit) << ", " + << checkReal(inst->fMin) << ", " + << checkReal(inst->fMax) << ", " + << checkReal(inst->fStep) << ")"; + break; + // clang-format on + } + EndLine(' '); + } + + virtual void visit(AddBargraphInst* inst) + { + *fOut << "state[" + quote(inst->fZone) + "] = 0."; + EndLine(' '); + } + + virtual void visit(AddSoundfileInst* inst) + { + *fOut << "self.add_soundfile(state, " << quote(inst->fSFZone) << ", ui_path, " << quote(inst->fLabel) << ", " << quote(inst->fURL) << ", x)"; + EndLine(' '); + } + + virtual void visit(Int32NumInst* inst) { *fOut << inst->fNum; } + + virtual void visit(Int64NumInst* inst) { *fOut << inst->fNum; } + + virtual void visit(Int32ArrayNumInst* inst) + { + *fOut << "jnp.array("; + char sep = '['; + for (size_t i = 0; i < inst->fNumTable.size(); i++) { + *fOut << sep << inst->fNumTable[i]; + sep = ','; + } + *fOut << "], dtype=jnp.int32)"; + } + + virtual void visit(FloatArrayNumInst* inst) + { + *fOut << "jnp.array("; + char sep = '['; + for (size_t i = 0; i < inst->fNumTable.size(); i++) { + *fOut << sep << checkFloat(inst->fNumTable[i]); + sep = ','; + } + *fOut << "], dtype=jnp.float32)"; + } + + virtual void visit(DoubleArrayNumInst* inst) + { + *fOut << "jnp.array("; + char sep = '['; + for (size_t i = 0; i < inst->fNumTable.size(); i++) { + *fOut << sep << checkDouble(inst->fNumTable[i]); + sep = ','; + } + *fOut << "], dtype=jnp.float64)"; + } + + virtual void visit(BinopInst* inst) + { + if (inst->fOpcode == kXOR) { + *fOut << "("; + inst->fInst1->accept(this); + *fOut << " ^ "; + inst->fInst2->accept(this); + *fOut << ")"; + } else { + // Operator prededence is not like C/C++, so for simplicity, we keep the fully parenthezid version + *fOut << "("; + inst->fInst1->accept(this); + *fOut << " "; + *fOut << gBinOpTable[inst->fOpcode]->fName; + *fOut << " "; + inst->fInst2->accept(this); + *fOut << ")"; + + bool opCodeIsBoolean = inst->fOpcode >= kGT && inst->fOpcode <= kXOR; + if (opCodeIsBoolean && !fIsDoingWhile) { + // these opcodes (>,>=,<,<= etc.) result in bools which should be re-cast to integers + *fOut << ".astype(jnp.int32)"; + } + } + } + + virtual void visit(DeclareVarInst* inst) + { + if (inst->fAddress->getAccess() & Address::kStaticStruct) { + *fOut << fTypeManager->generateType(inst->fType, inst->fAddress->getName()); + // Allocation is actually done in JAXInitFieldsVisitor + } else { + *fOut << fTypeManager->generateType(inst->fType, inst->fAddress->getName()); + if (inst->fValue) { + *fOut << " = "; + inst->fValue->accept(this); + } + } + EndLine(' '); + } + + virtual void visitAux(RetInst* inst, bool gen_empty) + { + if (inst->fResult) { + *fOut << "return "; + inst->fResult->accept(this); + EndLine(' '); + } else if (gen_empty) { + *fOut << "return"; + EndLine(' '); + } + } + + virtual void visit(DropInst* inst) + { + if (inst->fResult) { + inst->fResult->accept(this); + EndLine(' '); + } + } + + virtual void visit(DeclareFunInst* inst) + { + // Already generated + if (gFunctionSymbolTable.find(inst->fName) != gFunctionSymbolTable.end()) { + return; + } else { + gFunctionSymbolTable[inst->fName] = true; + } + + *fOut << "def " << inst->fName; + generateFunDefArgs(inst); + generateFunDefBody(inst); + } + + virtual void visit(DeclareBufferIterators* inst) + { + // Don't generate if no channels + if (inst->fChannels == 0) return; + + for (int i = 0; i < inst->fChannels; ++i) { + *fOut << inst->fBufferName1 <fBufferName2 << "[ " <fCode->fCode.size() == 0) { + *fOut << "):"; + fTab++; + tab(fTab, *fOut); + *fOut << "pass"; + fTab--; + tab(fTab, *fOut); + tab(fTab, *fOut); + } else { + // Function body + *fOut << "):"; + fTab++; + tab(fTab, *fOut); + inst->fCode->accept(this); + fTab--; + back(1, *fOut); + tab(fTab, *fOut); + } + } + + virtual void visit(NamedAddress* named) + { + // kStaticStruct are actually merged in the main DSP + if (named->getAccess() & Address::kStruct || named->getAccess() & Address::kStaticStruct) { + *fOut << "state[\""; + } + *fOut << named->fName; + if (named->getAccess() & Address::kStruct || named->getAccess() & Address::kStaticStruct) { + *fOut << "\"]"; + } + } + + /* + Indexed address can actually be values in an array or fields in a struct type + */ + virtual void visit(IndexedAddress* indexed) + { + if (fUseNumpy) { + + indexed->fAddress->accept(this); + DeclareStructTypeInst* struct_type = isStructType(indexed->getName()); + if (struct_type) { + Int32NumInst* field_index = static_cast(indexed->getIndex()); + *fOut << "[\"" << struct_type->fType->getName(field_index->fNum) << "\"]"; + } else { + Int32NumInst* field_index = dynamic_cast(indexed->getIndex()); + if (field_index) { + *fOut << "[" << field_index->fNum << "]"; + } else { + *fOut << "["; + indexed->getIndex()->accept(this); + *fOut << "]"; + } + } + + } else { + + indexed->fAddress->accept(this); + DeclareStructTypeInst* struct_type = isStructType(indexed->getName()); + if (struct_type) { + Int32NumInst* field_index = static_cast(indexed->getIndex()); + *fOut << "[\"" << struct_type->fType->getName(field_index->fNum) << "\"]"; + } else { + if (fIsStoringLhs) { + fWillSetArray = true; + return; + } + + if (fWillSetArray) { + *fOut << ".at"; + fWillSetArray = false; + } + + Int32NumInst* field_index = dynamic_cast(indexed->getIndex()); + if (field_index) { + *fOut << "[" << field_index->fNum << "]"; + } else { + *fOut << "["; + indexed->getIndex()->accept(this); + *fOut << "]"; + } + } + } + } + + virtual void visit(LoadVarAddressInst* inst) + { + faustassert(false); + } + + virtual void visit(StoreVarInst* inst) + { + fIsStoringLhs = true; + inst->fAddress->accept(this); + fIsStoringLhs = false; + *fOut << " = "; + + if (fWillSetArray) { + inst->fAddress->accept(this); + *fOut << ".set("; + inst->fValue->accept(this); + *fOut << ")"; + } else { + inst->fValue->accept(this); + } + + EndLine(' '); + } + + virtual void visit(::CastInst* inst) + { + if (isIntType(inst->fType->getType())) { + *fOut << "jnp.int32("; + inst->fInst->accept(this); + *fOut << ")"; + } else { + *fOut << fTypeManager->generateType(inst->fType) << "("; + inst->fInst->accept(this); + *fOut << ")"; + } + } + + // TODO : does not work, put this code in a function + virtual void visit(BitcastInst* inst) + {} + + virtual void visitCond(ValueInst* cond) + { + *fOut << "("; + cond->accept(this); + *fOut << " != 0)"; + } + + virtual void visit(Select2Inst* inst) + { + *fOut << "jnp.where("; + visitCond(inst->fCond); + *fOut << ", "; + inst->fThen->accept(this); + *fOut << ", "; + inst->fElse->accept(this); + *fOut << ")"; + } + + // Generate standard funcall (not 'method' like funcall...) + virtual void visit(FunCallInst* inst) + { + string name = (gPolyMathLibTable.find(inst->fName) != gPolyMathLibTable.end()) ? gPolyMathLibTable[inst->fName] : inst->fName; + if (fUseNumpy && name.rfind("jnp.") == 0) { + // turn "jnp." into "np." + name = name.substr(1, name.size() - 1); + } + *fOut << name << "("; + // Compile parameters + generateFunCallArgs(inst->fArgs.begin(), inst->fArgs.end(), inst->fArgs.size()); + *fOut << ")"; + } + + virtual void visit(IfInst* inst) + { + *fOut << "if "; + visitCond(inst->fCond); + *fOut << ":"; + fTab++; + tab(fTab, *fOut); + inst->fThen->accept(this); + fTab--; + back(1, *fOut); + if (inst->fElse->fCode.size() > 0) { + *fOut << "else:"; + fTab++; + tab(fTab, *fOut); + inst->fElse->accept(this); + fTab--; + back(1, *fOut); + } + tab(fTab, *fOut); + } + + virtual void visit(ForLoopInst* inst) + { + // Don't generate empty loops... + if (inst->fCode->size() == 0) return; + + fIsDoingWhile = true; + + fFinishLine = false; + inst->fInit->accept(this); + tab(fTab, *fOut); + *fOut << "while "; + inst->fEnd->accept(this); + fIsDoingWhile = false; + *fOut << ":"; + tab(fTab, *fOut); + fFinishLine = true; + fTab++; + tab(fTab, *fOut); + inst->fCode->accept(this); + tab(fTab, *fOut); + inst->fIncrement->accept(this); + fTab--; + back(1, *fOut); + tab(fTab, *fOut); + } + + virtual void visit(SimpleForLoopInst* inst) + { + // Don't generate empty loops... + if (inst->fCode->size() == 0) return; + *fOut << "for " << inst->getName() << " in "; + + if (inst->fReverse) { + // todo: + *fOut << "reverse("; + Int32NumInst* lower_bound = dynamic_cast(inst->fLowerBound); + faustassert(lower_bound); + *fOut << lower_bound->fNum << ":"; + Int32NumInst* upper_bound = dynamic_cast(inst->fUpperBound); + if (upper_bound) { + // If an Int32NumInst, we just generate it without any type information + // (see visit(Int32NumInst* inst) which adds type information that we don't want here) + *fOut << upper_bound->fNum; + } else { + inst->fUpperBound->accept(this); + } + *fOut << ")"; + } else { + Int32NumInst* lower_bound = dynamic_cast(inst->fLowerBound); + faustassert(lower_bound); + Int32NumInst* upper_bound = dynamic_cast(inst->fUpperBound); + if (upper_bound) { + *fOut << "range(" << lower_bound->fNum << ", " << upper_bound->fNum; + + if (upper_bound->fNum <= lower_bound->fNum) { + *fOut << ", -1"; + } + } else { + *fOut << "range(" << lower_bound->fNum << ", "; + inst->fUpperBound->accept(this); + } + *fOut << "):"; + } + + fTab++; + tab(fTab, *fOut); + inst->fCode->accept(this); + fTab--; + back(1, *fOut); + tab(fTab, *fOut); + } + + static void cleanup() { gFunctionSymbolTable.clear(); } +}; + +#endif diff -Nru faust-2.50.6+ds0/compiler/generator/julia/julia_code_container.cpp faust-2.54.9+ds0/compiler/generator/julia/julia_code_container.cpp --- faust-2.50.6+ds0/compiler/generator/julia/julia_code_container.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/julia/julia_code_container.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -173,11 +173,12 @@ // Print metadata declaration produceMetadata(n); - // Get sample rate method + // getSampleRate tab(n, *fOut); gGlobal->gJuliaVisitor->Tab(n); generateGetSampleRate("getSampleRate", "dsp", false, false)->accept(gGlobal->gJuliaVisitor); + // Info functions: getNumInputs/getNumOuputs tab(n, *fOut); produceInfoFunctions(n, "", "dsp", false, FunTyped::kDefault, gGlobal->gJuliaVisitor); @@ -190,8 +191,8 @@ } back(1, *fOut); *fOut << "end"; - tab(n, *fOut); + tab(n, *fOut); *fOut << "function instanceResetUserInterface!(dsp::" << fKlassName << "{T}) where {T}"; { @@ -200,8 +201,8 @@ } back(1, *fOut); *fOut << "end"; - tab(n, *fOut); + tab(n, *fOut); *fOut << "function instanceClear!(dsp::" << fKlassName << "{T}) where {T}"; { @@ -210,8 +211,8 @@ } back(1, *fOut); *fOut << "end"; - tab(n, *fOut); + tab(n, *fOut); *fOut << "function instanceConstants!(dsp::" << fKlassName << "{T}, sample_rate::Int32) where {T}"; { @@ -220,8 +221,8 @@ } back(1, *fOut); *fOut << "end"; - tab(n, *fOut); + tab(n, *fOut); *fOut << "function instanceInit!(dsp::" << fKlassName << "{T}, sample_rate::Int32) where {T}"; tab(n + 1, *fOut); @@ -232,8 +233,8 @@ *fOut << "instanceClear!(dsp)"; tab(n, *fOut); *fOut << "end"; - tab(n, *fOut); + tab(n, *fOut); *fOut << "function init!(dsp::" << fKlassName << "{T}, sample_rate::Int32) where {T}"; tab(n + 1, *fOut); @@ -242,10 +243,10 @@ *fOut << "instanceInit!(dsp, sample_rate)"; tab(n, *fOut); *fOut << "end"; + tab(n, *fOut); // JSON generation tab(n, *fOut); - tab(n, *fOut); *fOut << "function getJSON(dsp::" << fKlassName << "{T}) where {T}"; { string json = generateJSONAux(); @@ -255,10 +256,10 @@ } back(1, *fOut); *fOut << "end"; + tab(n, *fOut); // User interface tab(n, *fOut); - tab(n, *fOut); *fOut << "function buildUserInterface!(dsp::" << fKlassName << "{T}, ui_interface::UI) where {T}"; tab(n + 1, *fOut); gGlobal->gJuliaVisitor->Tab(n + 1); @@ -271,32 +272,6 @@ generateCompute(n); } -void JuliaCodeContainer::generateCompute(int n) -{ - // Generates declaration - tab(n, *fOut); - *fOut << "@inbounds function compute!(dsp::" << fKlassName - << "{T}, " << fFullCount << subst("::Int32, inputs::Matrix{$0}, outputs::Matrix{$0}) where {T}", xfloat()); - tab(n + 1, *fOut); - gGlobal->gJuliaVisitor->Tab(n + 1); - - // Generates local variables declaration and setup - generateComputeBlock(gGlobal->gJuliaVisitor); - - // Generates one single scalar loop - SimpleForLoopInst* loop = fCurLoop->generateSimpleScalarLoop(fFullCount); - loop->accept(gGlobal->gJuliaVisitor); - - /* - // TODO : atomic switch - // Currently for soundfile management - */ - generatePostComputeBlock(gGlobal->gJuliaVisitor); - - back(1, *fOut); - *fOut << "end" << endl; -} - void JuliaCodeContainer::produceMetadata(int tabs) { tab(tabs, *fOut); @@ -329,13 +304,41 @@ } // Scalar -JuliaScalarCodeContainer::JuliaScalarCodeContainer(const string& name, int numInputs, int numOutputs, std::ostream* out, - int sub_container_type) +JuliaScalarCodeContainer::JuliaScalarCodeContainer(const string& name, + int numInputs, int numOutputs, + std::ostream* out, + int sub_container_type) : JuliaCodeContainer(name, numInputs, numOutputs, out) { fSubContainerType = sub_container_type; } +void JuliaScalarCodeContainer::generateCompute(int n) +{ + // Generates declaration + tab(n, *fOut); + *fOut << "@inbounds function compute!(dsp::" << fKlassName + << "{T}, " << fFullCount << subst("::Int32, inputs::Matrix{$0}, outputs::Matrix{$0}) where {T}", xfloat()); + tab(n + 1, *fOut); + gGlobal->gJuliaVisitor->Tab(n + 1); + + // Generates local variables declaration and setup + generateComputeBlock(gGlobal->gJuliaVisitor); + + // Generates one single scalar loop + SimpleForLoopInst* loop = fCurLoop->generateSimpleScalarLoop(fFullCount); + loop->accept(gGlobal->gJuliaVisitor); + + /* + // TODO : atomic switch + // Currently for soundfile management + */ + generatePostComputeBlock(gGlobal->gJuliaVisitor); + + back(1, *fOut); + *fOut << "end" << endl; +} + // Vector JuliaVectorCodeContainer::JuliaVectorCodeContainer(const string& name, int numInputs, int numOutputs, std::ostream* out) : VectorCodeContainer(numInputs, numOutputs), JuliaCodeContainer(name, numInputs, numOutputs, out) diff -Nru faust-2.50.6+ds0/compiler/generator/julia/julia_code_container.hh faust-2.54.9+ds0/compiler/generator/julia/julia_code_container.hh --- faust-2.50.6+ds0/compiler/generator/julia/julia_code_container.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/julia/julia_code_container.hh 2022-12-17 10:41:42.000000000 +0000 @@ -25,9 +25,7 @@ #include "julia_instructions.hh" #include "code_container.hh" #include "dsp_factory.hh" -#include "omp_code_container.hh" #include "vec_code_container.hh" -#include "wss_code_container.hh" #ifdef WIN32 #pragma warning(disable : 4250) @@ -45,8 +43,6 @@ // Not used virtual void produceInternal() {} - void generateCompute(int n); - public: JuliaCodeContainer() {} @@ -63,6 +59,9 @@ static CodeContainer* createContainer(const std::string& name, int numInputs, int numOutputs, std::ostream* dst = new std::stringstream()); + + virtual void generateCompute(int tab) = 0; + }; class JuliaScalarCodeContainer : public JuliaCodeContainer { @@ -79,6 +78,7 @@ virtual ~JuliaScalarCodeContainer() {} + void generateCompute(int tab); }; class JuliaVectorCodeContainer : public VectorCodeContainer, public JuliaCodeContainer { diff -Nru faust-2.50.6+ds0/compiler/generator/julia/julia_instructions.hh faust-2.54.9+ds0/compiler/generator/julia/julia_instructions.hh --- faust-2.50.6+ds0/compiler/generator/julia/julia_instructions.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/julia/julia_instructions.hh 2022-12-17 10:41:42.000000000 +0000 @@ -72,7 +72,6 @@ } // Needed for waveforms - virtual void visit(Int32ArrayNumInst* inst) { char sep = '['; diff -Nru faust-2.50.6+ds0/compiler/generator/llvm/llvm_code_container.cpp faust-2.54.9+ds0/compiler/generator/llvm/llvm_code_container.cpp --- faust-2.50.6+ds0/compiler/generator/llvm/llvm_code_container.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/llvm/llvm_code_container.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -52,6 +52,9 @@ LLVMCodeContainer::LLVMCodeContainer(const string& name, int numInputs, int numOutputs) { LLVMContext* context = new LLVMContext(); +#if LLVM_VERSION_MAJOR == 15 + context->setOpaquePointers(false); +#endif Module* module = new Module(gGlobal->printCompilationOptions1() + ", v" + string(FAUSTVERSION), *context); init(name, numInputs, numOutputs, module, context); diff -Nru faust-2.50.6+ds0/compiler/generator/llvm/llvm_dsp_aux.cpp faust-2.54.9+ds0/compiler/generator/llvm/llvm_dsp_aux.cpp --- faust-2.50.6+ds0/compiler/generator/llvm/llvm_dsp_aux.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/llvm/llvm_dsp_aux.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -152,6 +152,9 @@ // Creates module and context fContext = new LLVMContext(); +#if LLVM_VERSION_MAJOR == 15 + fContext->setOpaquePointers(false); +#endif fModule = new Module(string(LLVM_BACKEND_NAME) + ", v" + string(FAUSTVERSION), *fContext); fDecoder = nullptr; } @@ -179,7 +182,11 @@ if (fJIT) { fJIT->runStaticConstructorsDestructors(true); // fModule is kept and deleted by fJIT + #if defined(__APPLE__) && LLVM_VERSION_MAJOR < 15 + // This cause 'recursive_mutex lock failed: Invalid argument' + // starting at LLVM_15, so deactivated for now delete fJIT; + #endif } delete fContext; delete fDecoder; @@ -740,6 +747,25 @@ return nullptr; } } + +LIBFAUST_API const char** getCWarningMessages(llvm_dsp_factory* factory) +{ + if (factory) { + vector include_list1 = factory->getWarningMessages(); + const char** include_list2 = (const char**)malloc(sizeof(char*) * (include_list1.size() + 1)); + + size_t i; + for (i = 0; i < include_list1.size(); i++) { + include_list2[i] = strdup(include_list1[i].c_str()); + } + + // Last element is NULL + include_list2[i] = nullptr; + return include_list2; + } else { + return nullptr; + } +} LIBFAUST_API char* getCDSPFactoryCompileOptions(llvm_dsp_factory* factory) { @@ -890,4 +916,3 @@ #ifdef __cplusplus } #endif - diff -Nru faust-2.50.6+ds0/compiler/generator/llvm/llvm_dsp_aux.hh faust-2.54.9+ds0/compiler/generator/llvm/llvm_dsp_aux.hh --- faust-2.50.6+ds0/compiler/generator/llvm/llvm_dsp_aux.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/llvm/llvm_dsp_aux.hh 2022-12-17 10:41:42.000000000 +0000 @@ -273,6 +273,7 @@ std::vector getLibraryList() { return fFactory->getLibraryList(); } std::vector getIncludePathnames() { return fFactory->getIncludePathnames(); } + std::vector getWarningMessages() { return fFactory->getWarningMessages(); } std::string getTarget() { return fFactory->getTarget(); } @@ -370,6 +371,8 @@ LIBFAUST_API const char** getCDSPFactoryIncludePathnames(llvm_dsp_factory* factory); +LIBFAUST_API const char** getCWarningMessages(llvm_dsp_factory* factory); + LIBFAUST_API char* getCDSPFactoryCompileOptions(llvm_dsp_factory* factory); LIBFAUST_API void deleteAllCDSPFactories(); diff -Nru faust-2.50.6+ds0/compiler/generator/llvm/llvm_dynamic_dsp_aux.cpp faust-2.54.9+ds0/compiler/generator/llvm/llvm_dynamic_dsp_aux.cpp --- faust-2.50.6+ds0/compiler/generator/llvm/llvm_dynamic_dsp_aux.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/llvm/llvm_dynamic_dsp_aux.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -384,6 +384,9 @@ } else { try { LLVMContext* context = new LLVMContext(); +#if LLVM_VERSION_MAJOR == 15 + context->setOpaquePointers(false); +#endif Module* module = ParseBitcodeFile(buffer, *context, error_msg); if (!module) return nullptr; llvm_dynamic_dsp_factory_aux* factory_aux @@ -491,6 +494,9 @@ } setlocale(LC_ALL, "C"); LLVMContext* context = new LLVMContext(); +#if LLVM_VERSION_MAJOR == 15 + context->setOpaquePointers(false); +#endif SMDiagnostic err; // parseIR takes ownership of the given buffer, so don't delete it Module* module = parseIR(buffer, err, *context).release(); @@ -622,11 +628,11 @@ argv1[argc1] = nullptr; // NULL terminated argv llvm_dynamic_dsp_factory_aux* factory_aux - = static_cast(createFactory(name_app.c_str(), - dsp_content.c_str(), - argc1, argv1, - error_msg, - true)); + = static_cast(createFactory(name_app, + dsp_content, + argc1, argv1, + error_msg, + true)); if (factory_aux) { factory_aux->setTarget(target); factory_aux->setOptlevel(opt_level); @@ -672,7 +678,7 @@ argv1[argc1] = nullptr; // NULL terminated argv llvm_dynamic_dsp_factory_aux* factory_aux - = static_cast(createFactory(name_app.c_str(), signals, argc1, argv1, error_msg)); + = static_cast(createFactory(name_app, signals, argc1, argv1, error_msg)); if (factory_aux && factory_aux->initJIT(error_msg)) { factory_aux->setTarget(target); factory_aux->setOptlevel(opt_level); diff -Nru faust-2.50.6+ds0/compiler/generator/llvm/llvm_instructions.hh faust-2.54.9+ds0/compiler/generator/llvm/llvm_instructions.hh --- faust-2.50.6+ds0/compiler/generator/llvm/llvm_instructions.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/llvm/llvm_instructions.hh 2022-12-17 10:41:42.000000000 +0000 @@ -58,9 +58,6 @@ #define MakeIdx(beg, end) llvm::ArrayRef(beg, end) #define MakeArgs(args) llvm::ArrayRef(args) #if LLVM_VERSION_MAJOR >= 14 - #if LLVM_VERSION_MAJOR == 15 - #error LLVM 15 not yet supported - #endif #define GetType(ptr) ptr->getType()->getScalarType()->getPointerElementType() #define MakeStructGEP(v1, v2) fBuilder->CreateStructGEP(GetType(v1), v1, v2); #define MyCreateLoad(var, is_volatile) fBuilder->CreateLoad(GetType(var), var, is_volatile) @@ -549,6 +546,7 @@ } else if (access & Address::kFunArgs) { return loadFunArg(name); } else if (access & Address::kStack || access & Address::kLoop) { + faustassert(fStackVars.find(name) != fStackVars.end()); return fStackVars[name]; } else if ((access & Address::kGlobal) || (access & Address::kStaticStruct)) { return fModule->getGlobalVariable(name, true); @@ -883,19 +881,19 @@ } } + /* // Strict select virtual void visit(Select2Inst* inst) { visitSelect(inst); } + */ - /* - // Lazy select + // Non-strict select virtual void visit(Select2Inst* inst) { visitIf(inst); } - */ // Select that computes both branches void visitSelect(Select2Inst* inst) diff -Nru faust-2.50.6+ds0/compiler/generator/rust/rust_code_container.cpp faust-2.54.9+ds0/compiler/generator/rust/rust_code_container.cpp --- faust-2.50.6+ds0/compiler/generator/rust/rust_code_container.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/rust/rust_code_container.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -173,6 +173,9 @@ fCodeProducer.Tab(n); generateGlobalDeclarations(&fCodeProducer); + tab(n, *fOut); + *fOut << "#[cfg_attr(feature = \"default-boxed\", derive(default_boxed::DefaultBoxed))]"; + tab(n, *fOut); *fOut << "pub struct " << fKlassName << " {"; tab(n + 1, *fOut); diff -Nru faust-2.50.6+ds0/compiler/generator/soul/soul_code_container.cpp faust-2.54.9+ds0/compiler/generator/soul/soul_code_container.cpp --- faust-2.50.6+ds0/compiler/generator/soul/soul_code_container.cpp 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/soul/soul_code_container.cpp 1970-01-01 00:00:00.000000000 +0000 @@ -1,476 +0,0 @@ -/************************************************************************ - ************************************************************************ - FAUST compiler - Copyright (C) 2003-2019 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., 675 Mass Ave, Cambridge, MA 02139, USA. - ************************************************************************ - ************************************************************************/ - -#include "soul_code_container.hh" -#include "global.hh" - -using namespace std; - -/* - SOUL backend description: - - - sub-containers are compiled as 'struct' with associated functions - - classInit is a Processor method for now (waiting for the SOUL external model to be ready) - - 'faustpower' function fallbacks to regular 'pow' (see powprim.h) - - 'boolean' type: - - are casted to 'int' (for indexes...) and kept for tests (in SelectInst...). - - 'int' results are casted to 'bool' for tests (in SelectInst...). - - see the SOULInstVisitor fIntAsBool variable. - - the 'fillXXX' function needs to generate the actual size of the table argument type. This is done using the - TableSizeVisitor class. - - bargraphs use 'output event' type and are outputting values at 50 Hz. The code is conditionally generated. -*/ - -dsp_factory_base* SOULCodeContainer::produceFactory() -{ - return new text_dsp_factory_aux( - fKlassName, "", "", ((static_cast(fOut)) ? static_cast(fOut)->str() : ""), ""); -} - -CodeContainer* SOULCodeContainer::createScalarContainer(const string& name, int sub_container_type) -{ - return new SOULScalarCodeContainer(name, 0, 1, sub_container_type, fOut); -} - -CodeContainer* SOULCodeContainer::createContainer(const string& name, int numInputs, int numOutputs, ostream* dst) -{ - CodeContainer* container; - - if (gGlobal->gOpenMPSwitch) { - throw faustexception("ERROR : OpenMP not supported for SOUL\n"); - } else if (gGlobal->gSchedulerSwitch) { - throw faustexception("ERROR : Scheduler not supported for SOUL\n"); - } else if (gGlobal->gVectorSwitch) { - throw faustexception("ERROR : Vector mode not supported for SOUL\n"); - // container = new SOULVectorCodeContainer(name, numInputs, numOutputs, dst); - } else { - container = new SOULScalarCodeContainer(name, numInputs, numOutputs, kInt, dst); - } - - return container; -} - -void SOULCodeContainer::produceInternal() -{ - int n = 0; - SOULSubContainerInstVisitor struct_visitor(fOut); - - // Global declarations - generateGlobalDeclarations(&struct_visitor); - - tab(n + 1, *fOut); - *fOut << "struct " << fKlassName; - tab(n + 1, *fOut); - *fOut << "{"; - tab(n + 2, *fOut); - - // Fields - struct_visitor.Tab(n + 2); - generateDeclarations(&struct_visitor); - - back(1, *fOut); - *fOut << "}" << endl; - - // Inits - tab(n + 1, *fOut); - *fOut << "void instanceInit" << fKlassName << " (" << fKlassName << "& this, int sample_rate)"; - tab(n + 1, *fOut); - *fOut << "{"; - tab(n + 2, *fOut); - struct_visitor.Tab(n + 2); - generateInit(&struct_visitor); - generateResetUserInterface(&struct_visitor); - generateClear(&struct_visitor); - back(1, *fOut); - *fOut << "}"; - - // Fill - string counter = "count"; - - // Retrieves the table size kept in gTableSizeVisitor to generate the correct table type - string fun_name = "fill" + fKlassName; - // We possibly have to generate several versions of the function with a different table size - for (const auto& it : gGlobal->gTableSizeVisitor->fSizeTable) { - string fun_name_aux = it.first; - int table_size = it.second; - if (startWith(fun_name_aux, fun_name)) { - tab(n + 1, *fOut); - if (fSubContainerType == kInt) { - tab(n + 1, *fOut); - *fOut << "void " << fun_name_aux << " (" << fKlassName << "& this, " - << subst("int $0, int[" + to_string(table_size) + "]& " + fTableName + ")", counter); - tab(n + 1, *fOut); - *fOut << "{"; - } else { - tab(n + 1, *fOut); - *fOut << "void " << fun_name_aux << " (" << fKlassName << "& this, " - << subst("int $0, $1[" + to_string(table_size) + "]& " + fTableName + ")", counter, - struct_visitor.getTypeManager()->fTypeDirectTable[itfloat()]); - tab(n + 1, *fOut); - *fOut << "{"; - } - tab(n + 2, *fOut); - struct_visitor.Tab(n + 2); - generateComputeBlock(&struct_visitor); - ForLoopInst* loop = fCurLoop->generateScalarLoop(counter); - loop->accept(&struct_visitor); - back(1, *fOut); - *fOut << "}"; - } - } - - tab(n + 1, *fOut); - *fOut << fKlassName << " new" << fKlassName << "() { " << fKlassName << " obj; return obj; }"; - tab(n + 1, *fOut); - *fOut << "void delete" << fKlassName << " (" << fKlassName << "& this) {}"; - tab(n + 1, *fOut); -} - -void SOULCodeContainer::produceInit(int tabs) -{ - tab(tabs, *fOut); - *fOut << "void init ()"; - tab(tabs, *fOut); - *fOut << "{"; - tab(tabs + 1, *fOut); - *fOut << "let sample_rate = int(processor.frequency);"; - tab(tabs + 1, *fOut); - if (fUIVisitor.fHasBargraph) { - *fOut << "fControlSlice = int (processor.frequency) / 50;"; - tab(tabs + 1, *fOut); - } - *fOut << "// classInit is not called here since the tables are actually not shared between instances"; - tab(tabs + 1, *fOut); - *fOut << "instanceInit (sample_rate);"; - tab(tabs, *fOut); - *fOut << "}"; - tab(tabs, *fOut); - - tab(tabs, *fOut); - *fOut << "void instanceInit (int sample_rate)"; - tab(tabs, *fOut); - *fOut << "{"; - tab(tabs + 1, *fOut); - *fOut << "// classInit has to be called for each instance since the tables are actually not shared between instances"; - tab(tabs + 1, *fOut); - *fOut << "classInit (sample_rate);"; - tab(tabs + 1, *fOut); - *fOut << "instanceConstants (sample_rate);"; - tab(tabs + 1, *fOut); - *fOut << "instanceResetUserInterface();"; - tab(tabs + 1, *fOut); - *fOut << "instanceClear();"; - tab(tabs, *fOut); - *fOut << "}"; - tab(tabs, *fOut); -} - -void SOULCodeContainer::produceClass() -{ - int n = 0; - - // Look for the "fillXXX" function - generateStaticInit(gGlobal->gTableSizeVisitor); - generateInit(gGlobal->gTableSizeVisitor); - - // Processor generation - tab(n, *fOut); - *fOut << "processor " << fKlassName; - tab(n, *fOut); - *fOut << "{"; - - // Fields - tab(n + 1, *fOut); - fCodeProducer.Tab(n + 1); - - if (gGlobal->gOutputLang == "soul-dsp") { - string json = generateJSONAux(); - *fOut << "// Event used to call additional methods"; - tab(n + 1, *fOut); - *fOut << "input event int eventbuildUserInterface [[json: \"" << flattenJSON(json) << "\"]];"; - tab(n + 1, *fOut); - *fOut << "input event int eventclassInit;"; - tab(n + 1, *fOut); - *fOut << "input event int eventinstanceConstants;"; - tab(n + 1, *fOut); - *fOut << "input event int eventinstanceResetUserInterface;"; - tab(n + 1, *fOut); - *fOut << "input event int eventinstanceClear;"; - tab(n + 1, *fOut); - tab(n + 1, *fOut); - } - - generateUserInterface(&fUIVisitor); - *fOut << fUIVisitor.fOut.str(); - generateDeclarations(&fCodeProducer); - - // Control - *fOut << "bool fUpdated;"; - tab(n + 1, *fOut); - if (fUIVisitor.fHasBargraph) { - *fOut << "int fControlSlice;"; - tab(n + 1, *fOut); - } - - // For control computation - if (fInt32ControlNum > 0) { - *fOut << "int32[" << fInt32ControlNum << "] iControl;"; - tab(n + 1, *fOut); - } - if (fRealControlNum > 0) { - *fOut << fCodeProducer.getTypeManager()->fTypeDirectTable[itfloat()] << "[" << fRealControlNum << "] fControl;"; - } - - // Global declarations - if (fGlobalDeclarationInstructions->fCode.size() > 0) { - tab(n + 1, *fOut); - fCodeProducer.Tab(n + 1); - generateGlobalDeclarations(&fCodeProducer); - } - - // UI - if (fUserInterfaceInstructions->fCode.size() > 0) { - tab(n + 1, *fOut); - fCodeProducer.Tab(n + 1); - generateUserInterface(&fCodeProducer); - } - - /* - // Debug version - if (gGlobal->gOutputLang == "soul-dsp") { - *fOut << "// Event handler used to call additional methods"; - tab(n + 1, *fOut); - *fOut << "event eventbuildUserInterface (int dummy) { console << \"eventbuildUserInterface\n\"; }"; - tab(n + 1, *fOut); - *fOut << "event eventclassInit (int sample_rate) { console << \"eventclassInit\n\"; classInit(sample_rate); }"; - tab(n + 1, *fOut); - *fOut << "event eventinstanceConstants (int sample_rate) { console << \"eventinstanceConstants\n\"; instanceConstants(sample_rate); }"; - tab(n + 1, *fOut); - *fOut << "event eventinstanceResetUserInterface (int dummy) { console << \"eventinstanceResetUserInterface\n\"; instanceResetUserInterface(); }"; - tab(n + 1, *fOut); - *fOut << "event eventinstanceClear (int dummy) { console << \"eventinstanceClear\n\"; instanceClear(); }"; - tab(n + 1, *fOut); - tab(n + 1, *fOut); - } - */ - - if (gGlobal->gOutputLang == "soul-dsp") { - *fOut << "// Event handler used to call additional methods"; - tab(n + 1, *fOut); - *fOut << "event eventbuildUserInterface (int dummy) {}"; - tab(n + 1, *fOut); - *fOut << "event eventclassInit (int sample_rate) { classInit(sample_rate); }"; - tab(n + 1, *fOut); - *fOut << "event eventinstanceConstants (int sample_rate) { instanceConstants(sample_rate); }"; - tab(n + 1, *fOut); - *fOut << "event eventinstanceResetUserInterface (int dummy) { instanceResetUserInterface(); }"; - tab(n + 1, *fOut); - *fOut << "event eventinstanceClear (int dummy) { instanceClear(); }"; - tab(n + 1, *fOut); - tab(n + 1, *fOut); - } - - // Generate gub containers - generateSubContainers(); - - // Missing math functions - tab(n + 1, *fOut); - if (gGlobal->gFloatSize == 1) { - *fOut << "float32 copysign(float32 x, float32 y) { return abs(x) * ((y < 0.0f) ? -1.0f : 1.0f); }"; - } else if (gGlobal->gFloatSize == 2) { - *fOut << "float64 copysign(float64 x, float64 y) { return abs(x) * ((y < 0.0) ? -1.0 : 1.0); }"; - } - tab(n + 1, *fOut); - - // inputs/outputs - tab(n + 1, *fOut); - *fOut << "int getNumInputs() { return " << fNumInputs << "; }"; - tab(n + 1, *fOut); - tab(n + 1, *fOut); - *fOut << "int getNumOuputs() { return " << fNumOutputs << "; }"; - tab(n + 1, *fOut); - - tab(n + 1, *fOut); - *fOut << "void classInit (int sample_rate)"; - tab(n + 1, *fOut); - *fOut << "{"; - tab(n + 2, *fOut); - fCodeProducer.Tab(n + 2); - // Rename the 'fillXXX' function with the proper table size - { - TableSizeCloneVisitor fill_funcall; - BlockInst* block1 = fill_funcall.getCode(fStaticInitInstructions); - block1->accept(&fCodeProducer); - BlockInst* block2 = fill_funcall.getCode(fPostStaticInitInstructions); - block2->accept(&fCodeProducer); - } - back(1, *fOut); - *fOut << "}"; - tab(n + 1, *fOut); - - tab(n + 1, *fOut); - *fOut << "void instanceConstants (int sample_rate)"; - tab(n + 1, *fOut); - *fOut << "{"; - tab(n + 2, *fOut); - fCodeProducer.Tab(n + 2); - // Rename the 'fillXXX' function with the proper table size - { - TableSizeCloneVisitor fill_funcall; - BlockInst* block1 = fill_funcall.getCode(fInitInstructions); - block1->accept(&fCodeProducer); - BlockInst* block2 = fill_funcall.getCode(fPostInitInstructions); - block2->accept(&fCodeProducer); - } - back(1, *fOut); - *fOut << "}"; - tab(n + 1, *fOut); - - tab(n + 1, *fOut); - *fOut << "void instanceResetUserInterface()"; - tab(n + 1, *fOut); - *fOut << "{"; - tab(n + 2, *fOut); - - // Control - *fOut << "fUpdated = true;"; - tab(n + 2, *fOut); - - fCodeProducer.Tab(n + 2); - generateResetUserInterface(&fCodeProducer); - back(1, *fOut); - *fOut << "}"; - tab(n + 1, *fOut); - - tab(n + 1, *fOut); - *fOut << "void instanceClear()"; - tab(n + 1, *fOut); - *fOut << "{"; - tab(n + 2, *fOut); - fCodeProducer.Tab(n + 2); - generateClear(&fCodeProducer); - back(1, *fOut); - *fOut << "}"; - tab(n + 1, *fOut); - - // Init - produceInit(n + 1); - - // Control - tab(n + 1, *fOut); - *fOut << "void control()"; - tab(n + 1, *fOut); - *fOut << "{"; - tab(n + 2, *fOut); - // Debug code - //*fOut << "console << \"control\\n\";"; - fCodeProducer.Tab(n + 2); - // Generates local variables declaration and setup - generateComputeBlock(&fCodeProducer); - back(1, *fOut); - *fOut << "}" << endl; - - // Compute - generateCompute(n + 1); - *fOut << "}" << endl; -} - -void SOULScalarCodeContainer::generateCompute(int n) -{ - tab(n, *fOut); - *fOut << "void run()"; - tab(n, *fOut); - *fOut << "{"; - tab(n + 1, *fOut); - *fOut << "// DSP loop running forever..."; - tab(n + 1, *fOut); - *fOut << "loop"; - tab(n + 1, *fOut); - *fOut << "{"; - tab(n + 2, *fOut); - *fOut << "if (fUpdated) { fUpdated = false; control(); }"; - tab(n + 2, *fOut); - tab(n + 2, *fOut); - - // Generates one sample computation - fCodeProducer.Tab(n + 2); - *fOut << "// Computes one sample"; - tab(n + 2, *fOut); - BlockInst* block = fCurLoop->generateOneSample(); - block->accept(&fCodeProducer); - - // Currently for soundfile management - generatePostComputeBlock(&fCodeProducer); - - tab(n + 2, *fOut); - if (fUIVisitor.fHasBargraph) { - *fOut << "// Updates fControlSlice once per sample"; - tab(n + 2, *fOut); - *fOut << "if (fControlSlice-- == 0) { fControlSlice = int (processor.frequency) / 50; }"; - tab(n + 2, *fOut); - } - *fOut << "// Moves all streams forward by one 'tick'"; - tab(n + 2, *fOut); - *fOut << "advance();"; - tab(n + 1, *fOut); - *fOut << "}"; - - tab(n, *fOut); - *fOut << "}" << endl; -} - -void SOULVectorCodeContainer::generateCompute(int n) -{ - tab(n, *fOut); - *fOut << "void run()"; - tab(n, *fOut); - *fOut << "{"; - tab(n + 1, *fOut); - *fOut << "// 'init' called once before starting the DSP loop"; - tab(n + 1, *fOut); - *fOut << "init (int(processor.frequency));"; - - tab(n + 1, *fOut); - tab(n + 1, *fOut); - *fOut << "// DSP loop running forever..."; - tab(n + 1, *fOut); - *fOut << "loop"; - *fOut << "{"; - tab(n + 2, *fOut); - - tab(n + 2, *fOut); - *fOut << "if (fUpdated) { fUpdated = false; control(); }"; - tab(n + 2, *fOut); - tab(n + 2, *fOut); - - // TODO - fCodeProducer.Tab(n + 2); - - tab(n + 2, *fOut); - *fOut << "// Move all streams forward by one 'tick'"; - tab(n + 2, *fOut); - *fOut << "advance();"; - tab(n + 1, *fOut); - *fOut << "}"; - - tab(n, *fOut); - *fOut << "}" << endl << endl; -} diff -Nru faust-2.50.6+ds0/compiler/generator/soul/soul_code_container.hh faust-2.54.9+ds0/compiler/generator/soul/soul_code_container.hh --- faust-2.50.6+ds0/compiler/generator/soul/soul_code_container.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/soul/soul_code_container.hh 1970-01-01 00:00:00.000000000 +0000 @@ -1,133 +0,0 @@ -/************************************************************************ - ************************************************************************ - FAUST compiler - Copyright (C) 2003-2019 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., 675 Mass Ave, Cambridge, MA 02139, USA. - ************************************************************************ - ************************************************************************/ - -#ifndef _SOUL_CODE_CONTAINER_H -#define _SOUL_CODE_CONTAINER_H - -#include "code_container.hh" -#include "omp_code_container.hh" -#include "soul_instructions.hh" -#include "vec_code_container.hh" -#include "wss_code_container.hh" - -#ifdef WIN32 -#pragma warning(disable : 4250) -#endif - -// Look for the "fillXXX" function call and keep the size of the third 'table' argument -struct TableSizeVisitor : public DispatchVisitor { - map fSizeTable; - - virtual void visit(FunCallInst* inst) - { - if (startWith(inst->fName, "fill")) { - ValuesIt it = inst->fArgs.begin(); - it++; - Int32NumInst* size = dynamic_cast(*it); - faustassert(size); - it++; - LoadVarInst* table = dynamic_cast(*it); - faustassert(table); - fSizeTable[inst->fName + "_" + to_string(size->fNum)] = size->fNum; - } - } -}; - -// Look for the "fillXXX" function call and rename it -struct TableSizeCloneVisitor : public BasicCloneVisitor { - virtual ValueInst* visit(FunCallInst* inst) - { - if (startWith(inst->fName, "fill")) { - ValuesIt it = inst->fArgs.begin(); - it++; - Int32NumInst* size = dynamic_cast(*it); - faustassert(size); - it++; - LoadVarInst* table = dynamic_cast(*it); - faustassert(table); - Values cloned_args; - for (const auto& it1 : inst->fArgs) { - cloned_args.push_back(it1->clone(this)); - } - return new FunCallInst(inst->fName + "_" + to_string(size->fNum), cloned_args, inst->fMethod); - } else { - return BasicCloneVisitor::visit(inst); - } - } - -}; - -class SOULCodeContainer : public virtual CodeContainer { - protected: - SOULInstVisitor fCodeProducer; - SOULInstUIVisitor fUIVisitor; - std::ostream* fOut; - - void produceInit(int tabs); - - virtual void printHeader() { CodeContainer::printHeader(*fOut); } - - protected: - SOULCodeContainer(const string& name, int numInputs, int numOutputs, ostream* out) : fCodeProducer(out), fOut(out) - { - initialize(numInputs, numOutputs); - fKlassName = name; - - if (!gGlobal->gTableSizeVisitor) { - gGlobal->gTableSizeVisitor = new TableSizeVisitor(); - } - } - - CodeContainer* createScalarContainer(const string& name, int sub_container_type); - void produceInternal(); - void produceClass(); - virtual void generateCompute(int tab) = 0; - - virtual dsp_factory_base* produceFactory(); - - public: - static CodeContainer* createContainer(const string& name, int numInputs, int numOutputs, ostream* dst); -}; - -class SOULScalarCodeContainer : public SOULCodeContainer { - private: - public: - SOULScalarCodeContainer(const string& name, int numInputs, int numOutputs, int sub_container_type, ostream* dst) - : SOULCodeContainer(name, numInputs, numOutputs, dst) - { - fSubContainerType = sub_container_type; - } - - void generateCompute(int tab); -}; - -class SOULVectorCodeContainer : public VectorCodeContainer, public SOULCodeContainer { - private: - public: - SOULVectorCodeContainer(const string& name, int numInputs, int numOutputs, ostream* dst) - : VectorCodeContainer(numInputs, numOutputs), SOULCodeContainer(name, numInputs, numOutputs, dst) - { - } - - void generateCompute(int tab); -}; - -#endif diff -Nru faust-2.50.6+ds0/compiler/generator/soul/soul_instructions.hh faust-2.54.9+ds0/compiler/generator/soul/soul_instructions.hh --- faust-2.50.6+ds0/compiler/generator/soul/soul_instructions.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/soul/soul_instructions.hh 1970-01-01 00:00:00.000000000 +0000 @@ -1,713 +0,0 @@ -/************************************************************************ - ************************************************************************ - FAUST compiler - Copyright (C) 2003-2019 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., 675 Mass Ave, Cambridge, MA 02139, USA. - ************************************************************************ - ************************************************************************/ - -#ifndef _SOUL_INSTRUCTIONS_H -#define _SOUL_INSTRUCTIONS_H - -#include -#include -#include -#include -#include - -#include "text_instructions.hh" -#include "faust/gui/PathBuilder.h" - -using namespace std; - -static vector gReplace = {' ', '(', ')', '\\', '.', '-'}; - -struct SOULInstUIVisitor : public DispatchVisitor, public PathBuilder { - std::stringstream fOut; - SOULStringTypeManager fTypeManager; - int fTab; - bool fHasBargraph; // Whether the DSP code has some Bargraphs - - std::vector > fMetaAux; - - using DispatchVisitor::visit; - - SOULInstUIVisitor(int tab = 1) : fTypeManager(xfloat(), "*"), fTab(tab), fHasBargraph(false) {} - - void addMeta() - { - if (fMetaAux.size() > 0) { - for (size_t i = 0; i < fMetaAux.size(); i++) { - if (!std::isdigit(fMetaAux[i].first[0])) { - fOut << ", " << "meta_" + gGlobal->getFreshID(fMetaAux[i].first) << ": " << quote(fMetaAux[i].second); - } - } - } - fMetaAux.clear(); - } - - std::string getSoulMatadata() - { - if (fMetaAux.size() > 0) { - for (size_t i = 0; i < fMetaAux.size(); i++) { - if (fMetaAux[i].first == "soul") return fMetaAux[i].second; - } - } - return ""; - } - - virtual void visit(AddMetaDeclareInst* inst) - { - fMetaAux.push_back(std::make_pair(inst->fKey, inst->fValue)); - } - - virtual void visit(AddButtonInst* inst) - { - if (gGlobal->gOutputLang == "soul-poly") { - fOut << "input event " << fTypeManager.fTypeDirectTable[itfloat()] - << " event_" << replaceCharList(inst->fLabel, gReplace, '_') - << " [[ name: " << quote(inst->fLabel) - << ", group: " << quote(buildPath(inst->fLabel)); - if (inst->fType != AddButtonInst::kDefaultButton) { - fOut << ", latching"; - } - fOut<< ", text: \"off|on\"" - << ", boolean"; - addMeta(); - fOut << " ]];"; - } else if (gGlobal->gOutputLang == "soul-hybrid") { - string soul_meta = getSoulMatadata(); - fOut << "input event " << fTypeManager.fTypeDirectTable[itfloat()] - << " " << ((soul_meta != "") ? soul_meta : replaceCharList(inst->fLabel, gReplace, '_')) - << " [[ name: " << quote(inst->fLabel) - << ", group: " << quote(buildPath(inst->fLabel)); - if (inst->fType != AddButtonInst::kDefaultButton) { - fOut << ", latching"; - } - fOut << ", text: \"off|on\"" - << ", boolean"; - addMeta(); - fOut << " ]];"; - } else { - fOut << "input event " << fTypeManager.fTypeDirectTable[itfloat()] - << " event" << inst->fZone - << " [[ name: " << quote(inst->fLabel) - << ", group: " << quote(buildPath(inst->fLabel)); - if (inst->fType != AddButtonInst::kDefaultButton) { - fOut << ", latching"; - } - fOut << ", text: \"off|on\"" - << ", boolean"; - addMeta(); - fOut << " ]];"; - } - tab(fTab, fOut); - } - - virtual void visit(AddSliderInst* inst) - { - if (gGlobal->gOutputLang == "soul-poly") { - fOut << "input event " << fTypeManager.fTypeDirectTable[itfloat()] - << " event_" << replaceCharList(inst->fLabel, gReplace, '_') - << " [[ name: " << quote(inst->fLabel) - << ", group: " << quote(buildPath(inst->fLabel)) - << ", min: " << checkReal(inst->fMin) - << ", max: " << checkReal(inst->fMax) - << ", init: " << checkReal(inst->fInit) - << ", step: " << checkReal(inst->fStep); - addMeta(); - fOut << " ]];"; - } else if (gGlobal->gOutputLang == "soul-hybrid") { - string soul_meta = getSoulMatadata(); - fOut << "input event " << fTypeManager.fTypeDirectTable[itfloat()] - << " " << ((soul_meta != "") ? soul_meta : replaceCharList(inst->fLabel, gReplace, '_')) - << " [[ name: " << quote(inst->fLabel) - << ", group: " << quote(buildPath(inst->fLabel)) - << ", min: " << checkReal(inst->fMin) - << ", max: " << checkReal(inst->fMax) - << ", init: " << checkReal(inst->fInit) - << ", step: " << checkReal(inst->fStep); - addMeta(); - fOut << " ]];"; - } else { - fOut << "input event " << fTypeManager.fTypeDirectTable[itfloat()] - << " event" << inst->fZone - << " [[ name: " << quote(inst->fLabel) - << ", group: " << quote(buildPath(inst->fLabel)) - << ", min: " << checkReal(inst->fMin) - << ", max: " << checkReal(inst->fMax) - << ", init: " << checkReal(inst->fInit) - << ", step: " << checkReal(inst->fStep); - addMeta(); - fOut << " ]];"; - } - tab(fTab, fOut); - } - - virtual void visit(AddBargraphInst* inst) - { - // We have bargraphs - fHasBargraph = true; - - if (gGlobal->gOutputLang == "soul-poly") { - fOut << "output event " << fTypeManager.fTypeDirectTable[itfloat()] - << " event_" << quote(replaceCharList(inst->fLabel, gReplace, '_')) - << " [[ name: " << quote(inst->fLabel) - << ", group: " << quote(buildPath(inst->fLabel)) - << ", min: " << checkReal(inst->fMin) - << ", max: " << checkReal(inst->fMax); - addMeta(); - fOut << " ]];"; - } else if (gGlobal->gOutputLang == "soul-hybrid") { - string soul_meta = getSoulMatadata(); - fOut << "output event " << fTypeManager.fTypeDirectTable[itfloat()] - << " " << ((soul_meta != "") ? soul_meta : replaceCharList(inst->fLabel, gReplace, '_')) - << " [[ name: " << quote(inst->fLabel) - << ", group: " << quote(buildPath(inst->fLabel)) - << ", min: " << checkReal(inst->fMin) - << ", max: " << checkReal(inst->fMax); - addMeta(); - fOut << " ]];"; - } else { - fOut << "output event " << fTypeManager.fTypeDirectTable[itfloat()] - << " event" << inst->fZone - << " [[ name: " << quote(inst->fLabel) - << ", group: " << quote(buildPath(inst->fLabel)) - << ", min: " << checkReal(inst->fMin) - << ", max: " << checkReal(inst->fMax); - addMeta(); - fOut << " ]];"; - } - tab(fTab, fOut); - } - - virtual void visit(OpenboxInst* inst) - { - switch (inst->fOrient) { - case OpenboxInst::kVerticalBox: - pushLabel("v:" + inst->fName); - break; - case OpenboxInst::kHorizontalBox: - pushLabel("h:" + inst->fName); - break; - case OpenboxInst::kTabBox: - pushLabel("t:" + inst->fName); - break; - } - fMetaAux.clear(); - } - - virtual void visit(CloseboxInst* inst) - { - popLabel(); - fMetaAux.clear(); - } - -}; - -class SOULInstVisitor : public TextInstVisitor { - private: - // Polymorphic math functions - map gPolyMathLibTable; - - // Whether to consider an 'int' as a 'boolean' later on in code generation - bool fIntAsBool; - - std::vector > fMetaAux; - - inline string checkFloat(float val) - { - return (std::isinf(val)) ? "inf" : T(val); - } - inline string checkDouble(double val) - { - return (std::isinf(val)) ? "inf" : T(val); - } - - std::string getSoulMatadata() - { - if (fMetaAux.size() > 0) { - for (size_t i = 0; i < fMetaAux.size(); i++) { - if (fMetaAux[i].first == "soul") return fMetaAux[i].second; - } - } - return ""; - } - - public: - SOULInstVisitor(std::ostream* out, int tab = 0) - : TextInstVisitor(out, ".", new SOULStringTypeManager(xfloat(), ""), tab) - { - // Polymath mapping int version - gPolyMathLibTable["abs"] = "abs"; - gPolyMathLibTable["max_i"] = "max"; - gPolyMathLibTable["min_i"] = "min"; - - // Polymath mapping float version - gPolyMathLibTable["max_f"] = "max"; - gPolyMathLibTable["min_f"] = "min"; - - gPolyMathLibTable["fabsf"] = "abs"; - gPolyMathLibTable["acosf"] = "acos"; - gPolyMathLibTable["asinf"] = "asin"; - gPolyMathLibTable["atanf"] = "atan"; - gPolyMathLibTable["atan2f"] = "atan2"; - gPolyMathLibTable["ceilf"] = "ceil"; - gPolyMathLibTable["cosf"] = "cos"; - gPolyMathLibTable["expf"] = "exp"; - gPolyMathLibTable["exp2f"] = "exp2"; - gPolyMathLibTable["exp10f"] = "exp10f"; - gPolyMathLibTable["floorf"] = "floor"; - gPolyMathLibTable["fmodf"] = "fmod"; - gPolyMathLibTable["logf"] = "log"; - gPolyMathLibTable["log2f"] = "log2"; - gPolyMathLibTable["log10f"] = "log10"; - gPolyMathLibTable["powf"] = "pow"; - gPolyMathLibTable["remainderf"] = "remainder"; - gPolyMathLibTable["rintf"] = "roundToInt"; - gPolyMathLibTable["roundf"] = "round"; - gPolyMathLibTable["sinf"] = "sin"; - gPolyMathLibTable["sqrtf"] = "sqrt"; - gPolyMathLibTable["tanf"] = "tan"; - - // Additional hyperbolic math functions are included in SOUL - gPolyMathLibTable["acoshf"] = "acosh"; - gPolyMathLibTable["asinhf"] = "asinh"; - gPolyMathLibTable["atanhf"] = "atanh"; - gPolyMathLibTable["coshf"] = "cosh"; - gPolyMathLibTable["sinhf"] = "sinh"; - gPolyMathLibTable["tanhf"] = "tanh"; - - gPolyMathLibTable["isnanf"] = "isnan"; - gPolyMathLibTable["isinff"] = "isinf"; - // Manually implemented - gPolyMathLibTable["copysignf"] = "copysign"; - - // Polymath mapping double version - gPolyMathLibTable["max_"] = "max"; - gPolyMathLibTable["min_"] = "min"; - - gPolyMathLibTable["fabs"] = "abs"; - gPolyMathLibTable["acos"] = "acos"; - gPolyMathLibTable["asin"] = "asin"; - gPolyMathLibTable["atan"] = "atan"; - gPolyMathLibTable["atan2"] = "atan2"; - gPolyMathLibTable["ceil"] = "ceil"; - gPolyMathLibTable["cos"] = "cos"; - gPolyMathLibTable["exp"] = "exp"; - gPolyMathLibTable["exp2"] = "exp2"; - gPolyMathLibTable["exp10"] = "exp10"; - gPolyMathLibTable["floor"] = "floor"; - gPolyMathLibTable["fmod"] = "fmod"; - gPolyMathLibTable["log"] = "log"; - gPolyMathLibTable["log2"] = "log2"; - gPolyMathLibTable["log10"] = "log10"; - gPolyMathLibTable["pow"] = "pow"; - gPolyMathLibTable["remainder"] = "remainder"; - gPolyMathLibTable["rint"] = "roundToInt"; - gPolyMathLibTable["round"] = "round"; - gPolyMathLibTable["sin"] = "sin"; - gPolyMathLibTable["sqrt"] = "sqrt"; - gPolyMathLibTable["tan"] = "tan"; - - // Additional hyperbolic math functions are included in SOUL - gPolyMathLibTable["acosh"] = "acosh"; - gPolyMathLibTable["asinh"] = "asinh"; - gPolyMathLibTable["atanh"] = "atanh"; - gPolyMathLibTable["cosh"] = "cosh"; - gPolyMathLibTable["sinh"] = "sinh"; - gPolyMathLibTable["tanh"] = "tanh"; - - gPolyMathLibTable["isnan"] = "isnan"; - gPolyMathLibTable["isinf"] = "isinf"; - // Manually implemented - gPolyMathLibTable["copysignf"] = "copysign"; - - fIntAsBool = false; - } - - virtual ~SOULInstVisitor() {} - - virtual void visit(AddMetaDeclareInst* inst) - { - fMetaAux.push_back(std::make_pair(inst->fKey, inst->fValue)); - } - - virtual void visit(OpenboxInst* inst) - { - fMetaAux.clear(); - } - - virtual void visit(CloseboxInst* inst) - { - fMetaAux.clear(); - } - - virtual void visit(AddButtonInst* inst) - { - *fOut << "// " << inst->fLabel; - EndLine(' '); - if (gGlobal->gOutputLang == "soul-poly") { - *fOut << "event event_" << replaceCharList(inst->fLabel, gReplace, '_') << " (" - << fTypeManager->fTypeDirectTable[itfloat()] << " val) { " << inst->fZone - << " = val; fUpdated = true; }"; - } else if (gGlobal->gOutputLang == "soul-hybrid") { - string soul_meta = getSoulMatadata(); - *fOut << "event " << ((soul_meta != "") ? soul_meta : replaceCharList(inst->fLabel, gReplace, '_')) - << " (" << fTypeManager->fTypeDirectTable[itfloat()] << " val) { " - << inst->fZone << " = val; fUpdated = true; }"; - fMetaAux.clear(); - } else { - *fOut << "event event" << inst->fZone << " (" << fTypeManager->fTypeDirectTable[itfloat()] << " val) { " - << inst->fZone << " = val; fUpdated = true; }"; - } - EndLine(' '); - } - - virtual void visit(AddSliderInst* inst) - { - *fOut << "// " << inst->fLabel << " [init = " << checkReal(inst->fInit) - << ", min = " << checkReal(inst->fMin) << ", max = " << checkReal(inst->fMax) - << ", step = " << checkReal(inst->fStep) << "]"; - EndLine(' '); - if (gGlobal->gOutputLang == "soul-poly") { - *fOut << "event event_" << replaceCharList(inst->fLabel, gReplace, '_') << " (" - << fTypeManager->fTypeDirectTable[itfloat()] << " val) { " << inst->fZone - << " = val; fUpdated = true; }"; - } else if (gGlobal->gOutputLang == "soul-hybrid") { - string soul_meta = getSoulMatadata(); - *fOut << "event " << ((soul_meta != "") ? soul_meta : replaceCharList(inst->fLabel, gReplace, '_')) - << " (" << fTypeManager->fTypeDirectTable[itfloat()] << " val) { " - << inst->fZone << " = val; fUpdated = true; }"; - fMetaAux.clear(); - } else { - *fOut << "event event" << inst->fZone << " (" << fTypeManager->fTypeDirectTable[itfloat()] << " val) { " - << inst->fZone << " = val; fUpdated = true; }"; - } - EndLine(' '); - } - - virtual void visit(AddBargraphInst* inst) - { - *fOut << "// " << inst->fLabel << " [min = " << checkReal(inst->fMin) << ", max = " << checkReal(inst->fMax) - << "]"; - EndLine(' '); - } - - virtual void visit(AddSoundfileInst* inst) - { - // Not supported for now - throw faustexception("ERROR : 'soundfile' primitive not yet supported for SOUL\n"); - } - - virtual void visit(DeclareVarInst* inst) - { - string name = inst->fAddress->getName(); - - // special case for input/output considered as 'streams' - if (startWith(name, "input")) { - *fOut << "input stream " << fTypeManager->fTypeDirectTable[itfloat()] << " " << name; - } else if (startWith(name, "output")) { - *fOut << "output stream " << fTypeManager->fTypeDirectTable[itfloat()] << " " << name; - } else { - if (inst->fAddress->getAccess() & Address::kConst) { - *fOut << "const "; - } - *fOut << fTypeManager->generateType(inst->fType, name); - if (inst->fValue) { - *fOut << " = "; - inst->fValue->accept(this); - } - } - EndLine(); - } - - virtual void visit(DeclareFunInst* inst) {} - - /* - Indexed adresses can actually be values in an array or fields in a struct type - */ - virtual void visit(IndexedAddress* indexed) - { - indexed->fAddress->accept(this); - DeclareStructTypeInst* struct_type = isStructType(indexed->getName()); - if (struct_type) { - Int32NumInst* field_index = static_cast(indexed->getIndex()); - *fOut << "." << struct_type->fType->getName(field_index->fNum); - } else { - if (dynamic_cast(indexed->getIndex())) { - *fOut << "["; - indexed->getIndex()->accept(this); - *fOut << "]"; - } else { - // wrap code is automatically added by the SOUL compiler (and the same if [idex] syntax is used) - *fOut << ".at ("; - indexed->getIndex()->accept(this); - *fOut << ")"; - } - } - } - - virtual void visit(StoreVarInst* inst) - { - // special case for 'output' considered as a 'stream' - if (startWith(inst->fAddress->getName(), "output")) { - inst->fAddress->accept(this); - *fOut << " << "; - inst->fValue->accept(this); - EndLine(); - // special case for 'bargraph' considered as an 'output event' - } else if (startWith(inst->fAddress->getName(), "fHbargraph") || - startWith(inst->fAddress->getName(), "fVbargraph")) { - - // value is stored in the bargraph variable - { - inst->fAddress->accept(this); - *fOut << " = "; - inst->fValue->accept(this); - EndLine(); - } - - // and the bargraph variable is sent using the 'output' event handler - { - *fOut << "if (fControlSlice == 0) { "; - *fOut << "event"; - inst->fAddress->accept(this); - *fOut << " << "; - inst->fAddress->accept(this); - *fOut << "; }"; - tab(fTab, *fOut); - } - - } else { - inst->fAddress->accept(this); - *fOut << " = "; - inst->fValue->accept(this); - EndLine(); - } - } - - virtual void visit(FloatNumInst* inst) { *fOut << checkFloat(inst->fNum); } - - virtual void visit(FloatArrayNumInst* inst) - { - char sep = '('; - for (size_t i = 0; i < inst->fNumTable.size(); i++) { - *fOut << sep << checkFloat(inst->fNumTable[i]); - sep = ','; - } - *fOut << ')'; - } - - virtual void visit(Int32ArrayNumInst* inst) - { - char sep = '('; - for (size_t i = 0; i < inst->fNumTable.size(); i++) { - *fOut << sep << inst->fNumTable[i]; - sep = ','; - } - *fOut << ')'; - } - - virtual void visit(Int64NumInst* inst) { *fOut << inst->fNum << "L"; } - - virtual void visit(DoubleNumInst* inst) { *fOut << checkDouble(inst->fNum); } - - virtual void visit(DoubleArrayNumInst* inst) - { - char sep = '('; - for (size_t i = 0; i < inst->fNumTable.size(); i++) { - *fOut << sep << checkDouble(inst->fNumTable[i]); - sep = ','; - } - *fOut << ')'; - } - - virtual void visit(::CastInst* inst) - { - string type = fTypeManager->generateType(inst->fType); - *fOut << type << " ("; - inst->fInst->accept(this); - *fOut << ")"; - } - - virtual void visit(BitcastInst* inst) { faustassert(false); } - - virtual void visit(Select2Inst* inst) - { - *fOut << "(bool ("; - fIntAsBool = true; - inst->fCond->accept(this); - fIntAsBool = false; - *fOut << ") ? "; - inst->fThen->accept(this); - *fOut << " : "; - inst->fElse->accept(this); - *fOut << ")"; - } - - virtual void visit(IfInst* inst) - { - *fOut << "if "; - *fOut << "(bool ("; - fIntAsBool = true; - visitCond(inst->fCond); - fIntAsBool = false; - *fOut << "))"; - *fOut << " {"; - fTab++; - tab(fTab, *fOut); - inst->fThen->accept(this); - fTab--; - back(1, *fOut); - if (inst->fElse->fCode.size() > 0) { - *fOut << "} else {"; - fTab++; - tab(fTab, *fOut); - inst->fElse->accept(this); - fTab--; - back(1, *fOut); - *fOut << "}"; - } else { - *fOut << "}"; - } - tab(fTab, *fOut); - } - - virtual void visit(BinopInst* inst) - { - bool cond1 = leftArgNeedsParentheses(inst, inst->fInst1); - bool cond2 = rightArgNeedsParentheses(inst, inst->fInst2); - - bool int_as_bool = fIntAsBool; - if (isBoolOpcode(inst->fOpcode) && !int_as_bool) { - *fOut << "int ("; - } - - // Hack to make it work again with 'soul' version 0.0.6 - if (isLogicalOpcode(inst->fOpcode)) { - Typed::VarType type = TypingVisitor::getType(inst->fInst1); - if (isInt64Type(type)) { - *fOut << "int64 ("; - } else if (isInt32Type(type) || isBoolType(type)) { - *fOut << "int32 ("; - } else { - faustassert(false); - } - } - - if (cond1) *fOut << "("; - inst->fInst1->accept(this); - if (cond1) *fOut << ")"; - - // Hack to make it work again with 'soul' version 0.0.6 - if (isLogicalOpcode(inst->fOpcode)) { - *fOut << ")"; - } - - *fOut << " "; - *fOut << gBinOpTable[inst->fOpcode]->fName; - *fOut << " "; - - // Hack to make it work again with 'soul' version 0.0.6 - if (isLogicalOpcode(inst->fOpcode)) { - Typed::VarType type = TypingVisitor::getType(inst->fInst2); - if (isInt64Type(type)) { - *fOut << "int64 ("; - } else if (isInt32Type(type) || isBoolType(type)) { - *fOut << "int32 ("; - } else { - faustassert(false); - } - } - - if (cond2) *fOut << "("; - inst->fInst2->accept(this); - if (cond2) *fOut << ")"; - - // Hack to make it work again with 'soul' version 0.0.6 - if (isLogicalOpcode(inst->fOpcode)) { - *fOut << ")"; - } - - if (isBoolOpcode(inst->fOpcode) && !int_as_bool) { - *fOut << ")"; - } - } - - virtual void visit(FunCallInst* inst) - { - string name; - if (gPolyMathLibTable.find(inst->fName) != gPolyMathLibTable.end()) { - name = gPolyMathLibTable[inst->fName]; - } else { - name = inst->fName; - } - - *fOut << gGlobal->getMathFunction(name) << ((inst->fArgs.size() > 0) ? " (" : "("); - - // Compile parameters - generateFunCallArgs(inst->fArgs.begin(), inst->fArgs.end(), inst->fArgs.size()); - *fOut << ")"; - } - - virtual void visit(ForLoopInst* inst) - { - // Don't generate empty loops... - if (inst->fCode->size() == 0) return; - - *fOut << "for ("; - - fFinishLine = false; - inst->fInit->accept(this); - *fOut << "; "; - - fIntAsBool = true; - inst->fEnd->accept(this); - fIntAsBool = false; - *fOut << "; "; - - inst->fIncrement->accept(this); - fFinishLine = true; - *fOut << ") {"; - - fTab++; - tab(fTab, *fOut); - inst->fCode->accept(this); - fTab--; - back(1, *fOut); - *fOut << "}"; - tab(fTab, *fOut); - } - - StringTypeManager* getTypeManager() { return fTypeManager; } -}; - -// For subcontainers: variable access is specific -class SOULSubContainerInstVisitor : public SOULInstVisitor { - public: - SOULSubContainerInstVisitor(std::ostream* out, int tab = 0) : SOULInstVisitor(out, tab) {} - - virtual void visit(NamedAddress* named) - { - if (named->getAccess() & Address::kStruct) { - *fOut << "this."; - } - *fOut << named->fName; - } -}; - -#endif diff -Nru faust-2.50.6+ds0/compiler/generator/statement.hh faust-2.54.9+ds0/compiler/generator/statement.hh --- faust-2.50.6+ds0/compiler/generator/statement.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/statement.hh 2022-12-17 10:41:42.000000000 +0000 @@ -24,7 +24,7 @@ #include -// implements a code statement with an optional condition +// Implements a code statement with an optional condition class Statement { private: diff -Nru faust-2.50.6+ds0/compiler/generator/struct_manager.hh faust-2.54.9+ds0/compiler/generator/struct_manager.hh --- faust-2.50.6+ds0/compiler/generator/struct_manager.hh 2022-10-02 14:11:18.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/struct_manager.hh 2022-12-17 10:41:42.000000000 +0000 @@ -303,7 +303,11 @@ if (is_struct) { // Arrays are allocated in iZone/fZone until fExternalMemory reaches 0 // kStaticStruct are always allocated in kExternal - if ((access & Address::kStaticStruct) || (fExternalMemory > 0 && array_typed->fSize > fDLThreshold)) { + // RW tables ("itblXX" and "ftblXX") are always allocated in kExternal + if ((access & Address::kStaticStruct) + || startWith(name, "itbl") + || startWith(name, "ftbl") + || (fExternalMemory > 0 && array_typed->fSize > fDLThreshold)) { fFieldTable.push_back(make_pair(name, MemoryDesc(fFieldIndex++, getStructSize(), getStructIntSize(), diff -Nru faust-2.50.6+ds0/compiler/generator/template/README.md faust-2.54.9+ds0/compiler/generator/template/README.md --- faust-2.50.6+ds0/compiler/generator/template/README.md 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/template/README.md 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,112 @@ + +# Developing a new backend + +The FIR (Faust Imperative Representation) is generated by converting signals to FIR instructions, defined in `instructions.hh` and `instructions.cpp` files. The conversion is done in `InstructionsCompiler` for the *-scalar* mode and `DAGInstructionsCompiler` for *-vec*, *-omp*, *-sch* Direct Acyclic Graph (DAG) based generators. + +Backends are implemented in sub-folders in the *generator* folder. They can be added in the compiler (either the `faust` executable or the `libfaust` library) using a compilation time activation model. + +## Adding the backend code + +A backend typically subclasses the `CodeContainer` class which will contain the FIR generated code for the different methods to generate (`init`, `buildUserInterface`, `compute`,etc.). For the template backend, the code in defined in the `template_code_container.hh`and `template_code_container.cpp` files: +- the `TemplateCodeContainer` is the base class for all backends code generation options (*-scalar*, *-vec*, *-omp*, *-sch*) +- the `TemplateScalarCodeContainer` implements the container used in *-scalar* +- the `TemplateVectorCodeContainer` implements the container used in *-vec* +- for options like *-omp*, *-sch*, the corresponding `TemplateOpenMPCodeContainer` and `TemplateWorkStealingCodeContainer` classes would have to be implemented and activated + +A `TemplateInstVisitor` visitor pattern implemented in `template_instructions.hh` is used to traverse the FIR code to generate the code. It actually shows an example of a [textual backend](#textual-backend), and is written by subclassing the `TextInstVisitor` base class for textual visitors. Note that this template code is given as an example and will have to be adapted to real use-cases. Looking at already written ones like the C or Julia backends can help. + +The `TemplateCodeContainer` base class implements in particular: +- the `produceClass` method wich is responsible to generate the entire piece of code +- the `produceInternal` method possibly used for sub containers +- the `produceMetadata` method to generate the global metadata +- the waveforms are inlined in the DSP structure (see `TemplateInitFieldsVisitor`usage in the `TemplateCodeContainer::produceClass` method, in the `// Fields` section) + +The `TemplateScalarCodeContainer` class implements the `compute` method to generate the specific version of DSP computation in *-scalar* mode. The `TemplateVectorCodeContainer` class implements the `compute` method to generate the specific version of DSP computation in *-vec* mode. + +### Inlining subcontainers + +The `rdtable` and `rwtable` primitives are treated as *sub containers* which possibly generate separated pieces of code (like additional C++ classes in the C++ backend, or LLVM modules in the LLVM backend). It may be easier to have the sub containers *be inlined* in the main module. This can be done at the appropriate locations using this kind of code: + +```c++ +// Rename 'sig' in 'dsp', remove 'dsp' allocation, +// inline subcontainers 'instanceInit' and 'fill' function call +inlineSubcontainersFunCalls(fInitInstructions)->accept(gGlobal->gTemplateVisitor); +``` + +Look at the `TemplateCodeContainer::produceClass()` method for a precise way of using it. + +## Compiling the backend + +Faust compilation and installation is based on CMake, you should look at the [Faust wiki pages](https://github.com/grame-cncm/faust/wiki). + +A set of cmake files have to be adapted for the new backed to be properly commpiled and activated: + +- targets included into your projects are specified using a configuration file located in the targets folder +- the [backends selection](https://github.com/grame-cncm/faust/wiki/backends#selecting-your-backends) is described using `backends` files located in the [backends](https://github.com/grame-cncm/faust/tree/master-dev/build/backends) folder. **These files will have to be adapted to activate the new backend** +- the backend build flag (like `TEMPLATE_BUILD` in this case) has to be added in the [scan_backends](https://github.com/grame-cncm/faust/blob/master-dev/build/misc/llvm.cmake#L14) function defined in the [llvm.cmake](https://github.com/grame-cncm/faust/blob/master-dev/build/misc/llvm.cmake) file + +The new backend may define some globals that have to be added in the `global` class defined in `global.hh`and `global.cpp` files. For instance the unique `TemplateInstVisitor` object is defined and allocated with the appropriate `#ifdef TEMPLATE_BUILD .... #endif` flags. + +## Activating the backend + +The new backend will have to be allocated and activated in the `libcode.cpp` file with the following kind of code: + +In the header part of the file: + +```c++ +#ifdef TEMPLATE_BUILD +#include "template_code_container.hh" +#endif +``` + +In the `enumBackends` function: + +```c++ +#ifdef TEMPLATE_BUILD + out << dspto << "Template" << endl; +#endif +``` + +With the following kind of code to create the backend: + +```c++ +static void compileTemplate(Tree signals, int numInputs, int numOutputs, ostream* out) +{ +#ifdef TEMPLATE_BUILD + // Backend configuration + gGlobal->gAllowForeignFunction = true; + gGlobal->gNeedManualPow = false; + gGlobal->gFAUSTFLOAT2Internal = true; + container = TemplateCodeContainer::createContainer(gGlobal->gClassName, numInputs, numOutputs, out); + + if (gGlobal->gVectorSwitch) { + new_comp = new DAGInstructionsCompiler(container); + } else { + new_comp = new InstructionsCompiler(container); + } + + if (gGlobal->gPrintXMLSwitch || gGlobal->gPrintDocSwitch) new_comp->setDescription(new Description()); + new_comp->compileMultiSignal(signals); +#else + throw faustexception("ERROR : -lang temp not supported since Template backend is not built\n"); +#endif +} +``` + +To be added in `generateCode` function with a new `temp` flag to be used in the `-lang` option (like `-lang temp` with this new template backend): + +```c++ +else if (gGlobal->gOutputLang == "temp") { + compileTemplate(signals, numInputs, numOutputs, dst.get()); +} +``` + +The `-lang` option in the `printHelp` documentation function has to be manually adapted. + +## Textual backend + +A textual backend will generate code in a C++ stream. It typically uses a subclass of `TextInstVisitor` to define its specific FIR traversing methods. + +## Binary backend + +A binary backend will generate binary code using an tailor-made output, which can greaty depends of the use-case. Look at the LLVM backend which outputs LLVM IR code, and the WASM backend which outputs binary WebAssembly code. diff -Nru faust-2.50.6+ds0/compiler/generator/template/template_code_container.cpp faust-2.54.9+ds0/compiler/generator/template/template_code_container.cpp --- faust-2.50.6+ds0/compiler/generator/template/template_code_container.cpp 1970-01-01 00:00:00.000000000 +0000 +++ faust-2.54.9+ds0/compiler/generator/template/template_code_container.cpp 2022-12-17 10:41:42.000000000 +0000 @@ -0,0 +1,229 @@ +/************************************************************************ + ************************************************************************ + FAUST compiler + Copyright (C) 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., 675 Mass Ave, Cambridge, MA 02139, USA. + ************************************************************************ + ************************************************************************/ + +#include "template_code_container.hh" +#include "Text.hh" +#include "exception.hh" +#include "fir_function_builder.hh" +#include "floats.hh" +#include "global.hh" + +using namespace std; + +map TemplateInstVisitor::gFunctionSymbolTable; + +dsp_factory_base* TemplateCodeContainer::produceFactory() +{ + return new text_dsp_factory_aux( + fKlassName, "", "", + ((dynamic_cast(fOut)) ? dynamic_cast(fOut)->str() : ""), ""); +} + +TemplateCodeContainer::TemplateCodeContainer(const std::string& name, int numInputs, int numOutputs, std::ostream* out) +{ + // Mandatory + initialize(numInputs, numOutputs); + fKlassName = name; + fOut = out; + + // Allocate one static visitor + if (!gGlobal->gTemplateVisitor) { + gGlobal->gTemplateVisitor = new TemplateInstVisitor(out, name); + } +} + +CodeContainer* TemplateCodeContainer::createScalarContainer(const string& name, int sub_container_type) +{ + return new TemplateScalarCodeContainer(name, 0, 1, fOut, sub_container_type); +} + +/* + The given template implements -scalar (= default) and -vec mode. + For options like -omp, -sch, the corresponding TemplateOpenMPCodeContainer + and TemplateWorkStealingCodeContainer classes would have to be implemented + and activated. +*/ +CodeContainer* TemplateCodeContainer::createContainer(const string& name, int numInputs, int numOutputs, ostream* dst) +{ + gGlobal->gDSPStruct = true; + CodeContainer* container; + + if (gGlobal->gOpenCLSwitch) { + throw faustexception("ERROR : OpenCL not supported for Template\n"); + } + if (gGlobal->gCUDASwitch) { + throw faustexception("ERROR : CUDA not supported for Template\n"); + } + + if (gGlobal->gOpenMPSwitch) { + throw faustexception("ERROR : OpenMP not supported for Template\n"); + } else if (gGlobal->gSchedulerSwitch) { + throw faustexception("ERROR : Scheduler not supported for Template\n"); + } else if (gGlobal->gVectorSwitch) { + container = new TemplateVectorCodeContainer(name, numInputs, numOutputs, dst); + } else { + container = new TemplateScalarCodeContainer(name, numInputs, numOutputs, dst, kInt); + } + + return container; +} + +// Used for subcontainers if 'inlining sub containers' model is not used +void TemplateCodeContainer::produceInternal() +{} + +/* + Given as an example of what a real backend would have to do: add or remove FIR visiting code etc. +*/ +void TemplateCodeContainer::produceClass() +{ + int n = 0; + *fOut << "TemplateCodeContainer::produceClass\n"; + + // Print header + + // Possibly missing mathematical functions + + // Possibly merge sub containers (with an empty 'produceInternal' method) + // mergeSubContainers(); + + // Functions + /* + // Only generate globals functions + for (const auto& it : fGlobalDeclarationInstructions->fCode) { + if (dynamic_cast

The Faust Project

Libraries from the community

abclib library

20 years of research, teaching and creation in mixed music using Faust language

Edge of Chaos

Faust Tap Library

Awesome library

Additional DSP resources

Granulation

A list of projects related to granulation:

Material in the abclib library

(ba.)ratio2semi

(ba.)ratio2cent

Counters and Time/Tempo Tools

(ba.)counter

Usage

(ba.)line

Usage

Function tabulation

Comparison program example

(ba.)tabulate

Usage

Example test program

(ba.)tabulate_chebychev

Usage

Example test program

Selectors (Conditions)

(ba.)if

Usage

Usage

(ba.)selector

Usage

Usage

(ba.)select2stereo

Usage

Usage

(ba.)selectn

Usage

Usage

Example test program

Example test program

(ba.)selectmulti

Usage

Usage

Example test program

Example test program

(ba.)selectoutn

Usage

Usage

Example

Example test program

Other

(ba.)latch

Usage

Usage

(ba.)sAndH

Usage

Usage

Usage

Usage

(ba.)peakhold

Usage

Usage

Usage

Usage

(ba.)impulsify

Usage

Usage

(ba.)automat

Usage

Usage

(ba.)listInterp

Usage

Usage

(ba.)bypass1

Usage

Usage

(ba.)bypass2

Usage

Usage

`(ba.)ratio2semi`

`(ba.)ratio2cent`

`(ba.)counter`

`(ba.)line`

`(ba.)tabulate`

`(ba.)tabulate_chebychev`

`(ba.)if`

`(ba.)selector`

`(ba.)select2stereo`

`(ba.)selectn`

`(ba.)selectmulti`

`(ba.)selectoutn`

`(ba.)latch`

`(ba.)sAndH`

`(ba.)peakhold`

`(ba.)impulsify`

`(ba.)automat`

`(ba.)listInterp`

`(ba.)bypass1`

`(ba.)bypass2`

`(ba.)bypass1to2`

`(ba.)bypass_fade`

`(ba.)toggle`

`(ba.)on_and_off`

`(ba.)bitcrusher`

`(ba.)slidingReduce`

`(ba.)slidingSump`

`(ba.)slidingMax`

`(ba.)slidingMin`

`(ba.)slidingMeanp`

`(ba.)slidingRMSp`

`(ba.)parallelOp`

`(ba.)parallelMax`

`(ba.)parallelMin`

`(ba.)parallelMean`

`(ba.)parallelRMS`

`(dm.)fdnrev0_demo`

`(fi.)zero`