+/************************************************************************
+
+ IMPORTANT NOTE : this file contains two clearly delimited sections :
+ the ARCHITECTURE section (in two parts) and the USER section. Each section
+ is governed by its own copyright and license. Please check individually
+ each section for license and copyright information.
+*************************************************************************/
+
+/*******************BEGIN ARCHITECTURE SECTION (part 1/2)****************/
+
+/************************************************************************
+ FAUST Architecture File
+ Copyright (C) 2003-2011 GRAME, Centre National de Creation Musicale
+ ---------------------------------------------------------------------
+ This Architecture section is free software; you can redistribute it
+ and/or modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 3 of
+ the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; If not, see <http://www.gnu.org/licenses/>.
+
+ EXCEPTION : As a special exception, you may create a larger work
+ that contains this FAUST architecture section and distribute
+ that work under terms of your choice, so long as this FAUST
+ architecture section is not modified.
+
+
+ ************************************************************************
+ ************************************************************************/
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <math.h>
+#include <errno.h>
+#include <time.h>
+#include <vector>
+#include <stack>
+#include <string>
+#include <map>
+#include <list>
+#include <iostream>
+#include <assert.h>
+
+#include <libgen.h>
+#include <jack/jack.h>
+#include <jack/jslist.h>
+
+using namespace std;
+
+// On Intel set FZ (Flush to Zero) and DAZ (Denormals Are Zero)
+// flags to avoid costly denormals
+#ifdef __SSE__
+ #include <xmmintrin.h>
+ #ifdef __SSE2__
+ #define AVOIDDENORMALS _mm_setcsr(_mm_getcsr() | 0x8040)
+ #else
+ #define AVOIDDENORMALS _mm_setcsr(_mm_getcsr() | 0x8000)
+ #endif
+#else
+ #define AVOIDDENORMALS
+#endif
+
+struct Meta : map<const char*, const char*>
+{
+ void declare (const char* key, const char* value) { (*this)[key]=value; }
+};
+
+#define max(x,y) (((x)>(y)) ? (x) : (y))
+#define min(x,y) (((x)<(y)) ? (x) : (y))
+
+// abs is now predefined
+//template<typename T> T abs (T a) { return (a<T(0)) ? -a : a; }
+
+inline int lsr (int x, int n) { return int(((unsigned int)x) >> n); }
+
+/******************************************************************************
+*******************************************************************************
+
+ VECTOR INTRINSICS
+
+*******************************************************************************
+*******************************************************************************/
+
+//inline void *aligned_calloc(size_t nmemb, size_t size) { return (void*)((unsigned)(calloc((nmemb*size)+15,sizeof(char)))+15 & 0xfffffff0); }
+//inline void *aligned_calloc(size_t nmemb, size_t size) { return (void*)((size_t)(calloc((nmemb*size)+15,sizeof(char)))+15 & ~15); }
+
+<<includeIntrinsic>>
+
+
+/******************************************************************************
+*******************************************************************************
+
+ GRAPHIC USER INTERFACE (v2)
+ abstract interfaces
+
+*******************************************************************************
+*******************************************************************************/
+
+using namespace std;
+
+
+struct uiItem;
+typedef void (*uiCallback)(float val, void* data);
+
+/**
+ * Graphic User Interface : abstract definition
+ */
+
+class UI
+{
+ typedef list<uiItem*> clist;
+ typedef map<float*, clist*> zmap;
+
+ private:
+ static list<UI*> fGuiList;
+ zmap fZoneMap;
+ bool fStopped;
+
+ public:
+
+ UI() : fStopped(false) {
+ fGuiList.push_back(this);
+ }
+
+ virtual ~UI() {
+ // suppression de this dans fGuiList
+ }
+
+ // -- zone management
+
+ void registerZone(float* z, uiItem* c)
+ {
+ if (fZoneMap.find(z) == fZoneMap.end()) fZoneMap[z] = new clist();
+ fZoneMap[z]->push_back(c);
+ }
+
+ void updateAllZones();
+
+ void updateZone(float* z);
+
+ static void updateAllGuis()
+ {
+ list<UI*>::iterator g;
+ for (g = fGuiList.begin(); g != fGuiList.end(); g++) {
+ (*g)->updateAllZones();
+ }
+ }
+
+ // -- active widgets
+
+ virtual void addButton(const char* label, float* zone) = 0;
+ virtual void addToggleButton(const char* label, float* zone) = 0;
+ virtual void addCheckButton(const char* label, float* zone) = 0;
+ virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step) = 0;
+ virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step) = 0;
+ virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step) = 0;
+
+ // -- passive widgets
+
+ virtual void addNumDisplay(const char* label, float* zone, int precision) = 0;
+ virtual void addTextDisplay(const char* label, float* zone, char* names[], float min, float max) = 0;
+ virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max) = 0;
+ virtual void addVerticalBargraph(const char* label, float* zone, float min, float max) = 0;
+
+ void addCallback(float* zone, uiCallback foo, void* data);
+
+ // -- widget's layouts
+
+ virtual void openFrameBox(const char* label) = 0;
+ virtual void openTabBox(const char* label) = 0;
+ virtual void openHorizontalBox(const char* label) = 0;
+ virtual void openVerticalBox(const char* label) = 0;
+ virtual void closeBox() = 0;
+
+ virtual void declare(float* zone, const char* key, const char* value) {}
+};
+
+class OSCUI : public UI
+{
+ public:
+
+ OSCUI() : UI()
+ {}
+
+ virtual ~OSCUI() {
+ // suppression de this dans fGuiList
+ }
+
+
+ // -- active widgets
+
+ virtual void addButton(const char* label, float* zone) {}
+ virtual void addToggleButton(const char* label, float* zone) {}
+ virtual void addCheckButton(const char* label, float* zone) {}
+ virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step) {}
+ virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step) {}
+ virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step) {}
+
+ // -- passive widgets
+
+ virtual void addNumDisplay(const char* label, float* zone, int precision) {}
+ virtual void addTextDisplay(const char* label, float* zone, char* names[], float min, float max) {}
+ virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max) {}
+ virtual void addVerticalBargraph(const char* label, float* zone, float min, float max) {}
+
+ void addCallback(float* zone, uiCallback foo, void* data);
+
+ // -- widget's layouts
+
+ virtual void openFrameBox(const char* label) {}
+ virtual void openTabBox(const char* label) {}
+ virtual void openHorizontalBox(const char* label) {}
+ virtual void openVerticalBox(const char* label) {}
+ virtual void closeBox() {}
+
+ virtual void declare(float* zone, const char* key, const char* value) {}
+};
+
+list<UI*> UI::fGuiList;
+
+/**
+ * User Interface Item: abstract definition
+ */
+
+class uiItem
+{
+ protected :
+
+ UI* fGUI;
+ float* fZone;
+ float fCache;
+
+ uiItem (UI* ui, float* zone) : fGUI(ui), fZone(zone), fCache(-123456.654321)
+ {
+ ui->registerZone(zone, this);
+ }
+
+ public :
+
+ virtual ~uiItem() {}
+
+ void modifyZone(float v)
+ {
+ fCache = v;
+ if (*fZone != v) {
+ *fZone = v;
+ fGUI->updateZone(fZone);
+ }
+ }
+
+ float cache() { return fCache; }
+ virtual void reflectZone() = 0;
+};
+
+
+/**
+ * Callback Item
+ */
+
+struct uiCallbackItem : public uiItem
+{
+ uiCallback fCallback;
+ void* fData;
+
+ uiCallbackItem(UI* ui, float* zone, uiCallback foo, void* data)
+ : uiItem(ui, zone), fCallback(foo), fData(data) {}
+
+ virtual void reflectZone() {
+ float v = *fZone;
+ fCache = v;
+ fCallback(v, fData);
+ }
+};
+
+/**
+ * Update all user items reflecting zone z
+ */
+
+inline void UI::updateZone(float* z)
+{
+ float v = *z;
+ clist* l = fZoneMap[z];
+ for (clist::iterator c = l->begin(); c != l->end(); c++) {
+ if ((*c)->cache() != v) (*c)->reflectZone();
+ }
+}
+
+/**
+ * Update all user items not up to date
+ */
+
+inline void UI::updateAllZones()
+{
+ for (zmap::iterator m = fZoneMap.begin(); m != fZoneMap.end(); m++) {
+ float* z = m->first;
+ clist* l = m->second;
+ float v = *z;
+ for (clist::iterator c = l->begin(); c != l->end(); c++) {
+ if ((*c)->cache() != v) (*c)->reflectZone();
+ }
+ }
+}
+
+inline void UI::addCallback(float* zone, uiCallback foo, void* data)
+{
+ new uiCallbackItem(this, zone, foo, data);
+};
+
+//----------------------------------------------------------------
+// definition du processeur de signal
+//----------------------------------------------------------------
+
+class dsp {
+ protected:
+ int fSamplingFreq;
+ public:
+ dsp() {}
+ virtual ~dsp() {}
+
+ virtual int getNumInputs() = 0;
+ virtual int getNumOutputs() = 0;
+ virtual void buildUserInterface(UI* interface) = 0;
+ virtual void init(int samplingRate) = 0;
+ virtual void compute(int len, float** inputs, float** outputs) = 0;
+ virtual void conclude() {}
+};
+
+
+/********************END ARCHITECTURE SECTION (part 1/2)****************/
+
+/**************************BEGIN USER SECTION **************************/
+
+<<includeclass>>
+
+/***************************END USER SECTION ***************************/
+
+/*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
+
+
+/******************************************************************************
+*******************************************************************************
+
+ JACK AUDIO INTERFACE
+
+*******************************************************************************
+*******************************************************************************/
+
+#define JACK_DRIVER_NAME_MAX 15
+#define JACK_DRIVER_PARAM_NAME_MAX 15
+#define JACK_DRIVER_PARAM_STRING_MAX 63
+#define JACK_DRIVER_PARAM_DESC 255
+#define JACK_PATH_MAX 511
+
+/** Driver parameter types */
+typedef enum
+{
+ JackDriverParamInt = 1,
+ JackDriverParamUInt,
+ JackDriverParamChar,
+ JackDriverParamString,
+ JackDriverParamBool
+} jack_driver_param_type_t;
+
+/** Driver parameter value */
+typedef union
+{
+ uint32_t ui;
+ int32_t i;
+ char c;
+ char str[JACK_DRIVER_PARAM_STRING_MAX + 1];
+} jack_driver_param_value_t;
+
+
+/** A driver parameter descriptor */
+typedef struct {
+ char name[JACK_DRIVER_NAME_MAX + 1]; /**< The parameter's name */
+ char character; /**< The parameter's character (for getopt, etc) */
+ jack_driver_param_type_t type; /**< The parameter's type */
+ jack_driver_param_value_t value; /**< The parameter's (default) value */
+ char short_desc[64]; /**< A short (~30 chars) description for the user */
+ char long_desc[1024]; /**< A longer description for the user */
+}
+jack_driver_param_desc_t;
+
+/** A driver parameter */
+typedef struct {
+ char character;
+ jack_driver_param_value_t value;
+}
+jack_driver_param_t;
+
+/** A struct for describing a jack driver */
+typedef struct {
+ char name[JACK_DRIVER_NAME_MAX + 1]; /**< The driver's canonical name */
+ char desc[JACK_DRIVER_PARAM_DESC + 1]; /**< The driver's extended description */
+ char file[JACK_PATH_MAX + 1]; /**< The filename of the driver's shared object file */
+ uint32_t nparams; /**< The number of parameters the driver has */
+ jack_driver_param_desc_t * params; /**< An array of parameter descriptors */
+}
+jack_driver_desc_t;
+
+// class JackArgParser ***************************************************
+class JackArgParser
+{
+ private:
+
+ std::string fArgString;
+ int fArgc;
+ std::vector<std::string> fArgv;
+
+ public:
+
+ JackArgParser (const char* arg);
+ ~JackArgParser();
+ std::string GetArgString();
+ int GetNumArgv();
+ int GetArgc();
+ int GetArgv (std::vector<std::string>& argv);
+ int GetArgv (char** argv);
+ void DeleteArgv (const char** argv);
+ void ParseParams (jack_driver_desc_t* desc, JSList** param_list);
+ void FreeParams (JSList* param_list);
+};
+
+JackArgParser::JackArgParser (const char* arg)
+{
+ printf ("JackArgParser::JackArgParser, arg_string : '%s' \n", arg);
+
+ fArgc = 0;
+ //if empty string
+ if (strlen(arg) == 0)
+ return;
+ fArgString = string(arg);
+ //else parse the arg string
+ const size_t arg_len = fArgString.length();
+ unsigned int i = 0;
+ size_t pos = 0;
+ size_t start = 0;
+ size_t copy_start = 0;
+ size_t copy_length = 0;
+ //we need a 'space terminated' string
+ fArgString += " ";
+ //first fill a vector with args
+ do {
+ //find the first non-space character from the actual position
+ start = fArgString.find_first_not_of (' ', start);
+ //get the next quote or space position
+ pos = fArgString.find_first_of (" \"" , start);
+ //no more quotes or spaces, consider the end of the string
+ if (pos == string::npos)
+ pos = arg_len;
+ //if double quote
+ if (fArgString[pos] == '\"') {
+ //first character : copy the substring
+ if (pos == start) {
+ copy_start = start + 1;
+ pos = fArgString.find ('\"', ++pos);
+ copy_length = pos - copy_start;
+ start = pos + 1;
+ }
+ //else there is someting before the quote, first copy that
+ else {
+ copy_start = start;
+ copy_length = pos - copy_start;
+ start = pos;
+ }
+ }
+ //if space
+ if (fArgString[pos] == ' ') {
+ //short option descriptor
+ if ((fArgString[start] == '-') && (fArgString[start + 1] != '-')) {
+ copy_start = start;
+ copy_length = 2;
+ start += copy_length;
+ }
+ //else copy all the space delimitated string
+ else {
+ copy_start = start;
+ copy_length = pos - copy_start;
+ start = pos + 1;
+ }
+ }
+ //then push the substring to the args vector
+ fArgv.push_back (fArgString.substr (copy_start, copy_length));
+ printf("JackArgParser::JackArgParser, add : '%s' \n", (*fArgv.rbegin()).c_str());
+ } while (start < arg_len);
+
+ //finally count the options
+ for (i = 0; i < fArgv.size(); i++)
+ if (fArgv[i].at(0) == '-')
+ fArgc++;
+}
+
+JackArgParser::~JackArgParser()
+{}
+
+string JackArgParser::GetArgString()
+{
+ return fArgString;
+}
+
+int JackArgParser::GetNumArgv()
+{
+ return fArgv.size();
+}
+
+int JackArgParser::GetArgc()
+{
+ return fArgc;
+}
+
+int JackArgParser::GetArgv(vector<string>& argv)
+{
+ argv = fArgv;
+ return 0;
+}
+
+int JackArgParser::GetArgv(char** argv)
+{
+ //argv must be NULL
+ if (argv)
+ return -1;
+ //else allocate and fill it
+ argv = (char**)calloc(fArgv.size(), sizeof(char*));
+ for (unsigned int i = 0; i < fArgv.size(); i++) {
+ argv[i] = (char*)calloc(fArgv[i].length(), sizeof(char));
+ fill_n(argv[i], fArgv[i].length() + 1, 0);
+ fArgv[i].copy(argv[i], fArgv[i].length());
+ }
+ return 0;
+}
+
+void JackArgParser::DeleteArgv(const char** argv)
+{
+ unsigned int i;
+ for (i = 0; i < fArgv.size(); i++)
+ free((void*)argv[i]);
+ free((void*)argv);
+}
+
+void JackArgParser::ParseParams(jack_driver_desc_t* desc, JSList** param_list)
+{
+ string options_list;
+ unsigned long i = 0;
+ unsigned int param = 0;
+ size_t param_id = 0;
+ JSList* params = NULL;
+ jack_driver_param_t* intclient_param;
+
+ for (i = 0; i < desc->nparams; i++)
+ options_list += desc->params[i].character;
+
+ for (param = 0; param < fArgv.size(); param++)
+ {
+ if (fArgv[param][0] == '-')
+ {
+ //valid option
+ if ((param_id = options_list.find_first_of(fArgv[param].at(1))) != string::npos)
+ {
+ intclient_param = static_cast<jack_driver_param_t*>(calloc(1, sizeof(jack_driver_param_t)));
+ intclient_param->character = desc->params[param_id].character;
+
+ switch (desc->params[param_id].type)
+ {
+ case JackDriverParamInt:
+ if (param + 1 < fArgv.size()) // something to parse
+ intclient_param->value.i = atoi(fArgv[param + 1].c_str());
+ break;
+
+ case JackDriverParamUInt:
+ if (param + 1 < fArgv.size()) // something to parse
+ intclient_param->value.ui = strtoul(fArgv[param + 1].c_str(), NULL, 10);
+ break;
+
+ case JackDriverParamChar:
+ if (param + 1 < fArgv.size()) // something to parse
+ intclient_param->value.c = fArgv[param + 1][0];
+ break;
+
+ case JackDriverParamString:
+ if (param + 1 < fArgv.size()) // something to parse
+ fArgv[param + 1].copy(intclient_param->value.str, min(static_cast<int>(fArgv[param + 1].length()), JACK_DRIVER_PARAM_STRING_MAX));
+ break;
+
+ case JackDriverParamBool:
+ intclient_param->value.i = true;
+ break;
+ }
+ //add to the list
+ params = jack_slist_append(params, intclient_param);
+ }
+ //invalid option
+ else
+ printf("Invalid option '%c'\n", fArgv[param][1]);
+ }
+ }
+
+ assert(param_list);
+ *param_list = params;
+}
+
+void JackArgParser::FreeParams(JSList* param_list)
+{
+ JSList *node_ptr = param_list;
+ JSList *next_node_ptr;
+
+ while (node_ptr) {
+ next_node_ptr = node_ptr->next;
+ free(node_ptr->data);
+ free(node_ptr);
+ node_ptr = next_node_ptr;
+ }
+}
+
+struct JackFaustInternal {
+
+ //----------------------------------------------------------------------------
+ // number of input and output channels
+ //----------------------------------------------------------------------------
+
+ int fNumInChans;
+ int fNumOutChans;
+
+ //----------------------------------------------------------------------------
+ // Jack ports
+ //----------------------------------------------------------------------------
+
+ jack_port_t* fInputPorts[256];
+ jack_port_t* fOutputPorts[256];
+
+ //----------------------------------------------------------------------------
+ // tables of noninterleaved input and output channels for FAUST
+ //----------------------------------------------------------------------------
+
+ float* fInChannel[256];
+ float* fOutChannel[256];
+
+ jack_client_t* fClient;
+ UI* fInterface;
+ mydsp fDSP;
+
+ JackFaustInternal(jack_client_t* client, const JSList* params)
+ :fClient(client)
+ {}
+
+ ~JackFaustInternal()
+ {
+ delete fInterface;
+ }
+
+ int Open()
+ {
+ char** physicalInPorts;
+ char** physicalOutPorts;
+
+ fInterface = new OSCUI();
+ fDSP.buildUserInterface(fInterface);
+
+ jack_set_process_callback(fClient, process, this);
+ jack_set_sample_rate_callback(fClient, srate, this);
+
+ fNumInChans = fDSP.getNumInputs();
+ fNumOutChans = fDSP.getNumOutputs();
+
+ for (int i = 0; i < fNumInChans; i++) {
+ char buf[256];
+ snprintf(buf, 256, "in_%d", i);
+ fInputPorts[i] = jack_port_register(fClient, buf, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
+ }
+ for (int i = 0; i < fNumOutChans; i++) {
+ char buf[256];
+ snprintf(buf, 256, "out_%d", i);
+ fOutputPorts[i] = jack_port_register(fClient, buf, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
+ }
+
+ fDSP.init(jack_get_sample_rate(fClient));
+
+ physicalInPorts = (char **)jack_get_ports(fClient, NULL, NULL, JackPortIsPhysical|JackPortIsInput);
+ physicalOutPorts = (char **)jack_get_ports(fClient, NULL, NULL, JackPortIsPhysical|JackPortIsOutput);
+
+ if (jack_activate(fClient)) {
+ fprintf(stderr, "cannot activate client");
+ return -1;
+ }
+
+ if (physicalOutPorts != NULL) {
+ for (int i = 0; i < fNumInChans && physicalOutPorts[i]; i++) {
+ jack_connect(fClient, physicalOutPorts[i], jack_port_name(fInputPorts[i]));
+ }
+ }
+
+ if (physicalInPorts != NULL) {
+ for (int i = 0; i < fNumOutChans && physicalInPorts[i]; i++) {
+ jack_connect(fClient, jack_port_name(fOutputPorts[i]), physicalInPorts[i]);
+ }
+ }
+
+ return 0;
+ }
+
+ //----------------------------------------------------------------------------
+ // Jack Callbacks
+ //----------------------------------------------------------------------------
+
+ static int srate(jack_nframes_t nframes, void *arg)
+ {
+ printf("the sample rate is now %u/sec\n", nframes);
+ return 0;
+ }
+
+ static int process(jack_nframes_t nframes, void *arg)
+ {
+ JackFaustInternal* obj = (JackFaustInternal*)arg;
+ AVOIDDENORMALS;
+
+ for (int i = 0; i < obj->fNumInChans; i++) {
+ obj->fInChannel[i] = (float *)jack_port_get_buffer(obj->fInputPorts[i], nframes);
+ }
+ for (int i = 0; i < obj->fNumOutChans; i++) {
+ obj->fOutChannel[i] = (float *)jack_port_get_buffer(obj->fOutputPorts[i], nframes);
+ }
+ obj->fDSP.compute(nframes, obj->fInChannel, obj->fOutChannel);
+
+ return 0;
+ }
+
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+jack_driver_desc_t* jack_get_descriptor()
+{
+ jack_driver_desc_t *desc;
+ unsigned int i;
+ desc = (jack_driver_desc_t*)calloc(1, sizeof(jack_driver_desc_t));
+
+ strcpy(desc->name, "faust"); // size MUST be less then JACK_DRIVER_NAME_MAX + 1
+ strcpy(desc->desc, " Faust generated internal"); // size MUST be less then JACK_DRIVER_PARAM_DESC + 1
+
+ desc->nparams = 0;
+ /*
+ desc->nparams = 2;
+ desc->params = (jack_driver_param_desc_t*)calloc(desc->nparams, sizeof(jack_driver_param_desc_t));
+
+ i = 0;
+ strcpy(desc->params[i].name, "channels");
+ desc->params[i].character = 'c';
+ desc->params[i].type = JackDriverParamInt;
+ desc->params[i].value.ui = 0;
+ strcpy(desc->params[i].short_desc, "Maximum number of channels");
+ strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
+
+ i++;
+ strcpy(desc->params[i].name, "inchannels");
+ desc->params[i].character = 'i';
+ desc->params[i].type = JackDriverParamInt;
+ desc->params[i].value.ui = 0;
+ strcpy(desc->params[i].short_desc, "Maximum number of input channels");
+ strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
+ */
+
+ return desc;
+}
+
+int jack_internal_initialize(jack_client_t* client, const JSList* params)
+{
+ try {
+
+ JackFaustInternal* internal = new JackFaustInternal(client, params);
+ if (internal->Open() == 0) {
+ return 0;
+ } else {
+ delete internal;
+ return 1;
+ }
+
+ } catch (...) {
+ return 1;
+ }
+}
+
+int jack_initialize(jack_client_t* client, const char* load_init)
+{
+ JSList* params = NULL;
+ jack_driver_desc_t *desc = jack_get_descriptor();
+
+ JackArgParser parser(load_init);
+ if (parser.GetArgc() > 0)
+ parser.ParseParams(desc, ¶ms);
+
+ int res = jack_internal_initialize(client, params);
+ parser.FreeParams(params);
+ return res;
+}
+
+void jack_finish(void* arg)
+{
+ JackFaustInternal* internal = static_cast<JackFaustInternal*>(arg);
+
+ if (internal) {
+ printf("Unloading internal\n");
+ delete internal;
+ }
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/********************END ARCHITECTURE SECTION (part 2/2)****************/
+
+
projects / Faustine.git / blobdiff