cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/puredata.cpp

@@ -0,0 +1,636 @@
+/************************************************************************
+ ************************************************************************
+    FAUST Architecture File
+    Copyright (C) 2006-2011 Albert Graef <Dr.Graef@t-online.de>
+    ---------------------------------------------------------------------
+    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 the GNU C Library; if not, write to the Free
+    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+    02111-1307 USA. 
+ ************************************************************************
+ ************************************************************************/
+
+/* Pd architecture file, written by Albert Graef <Dr.Graef@t-online.de>.
+   This was derived from minimal.cpp included in the Faust distribution.
+   Please note that this is to be compiled as a shared library, which is
+   then loaded dynamically by Pd as an external. */
+
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+#include "faust/misc.h"
+#include "faust/gui/UI.h"
+#include "faust/gui/meta.h"
+#include "faust/dsp/dsp.h"
+
+/******************************************************************************
+*******************************************************************************
+
+							       VECTOR INTRINSICS
+
+*******************************************************************************
+*******************************************************************************/
+
+<<includeIntrinsic>>
+
+/***************************************************************************
+   Pd UI interface
+ ***************************************************************************/
+
+enum ui_elem_type_t {
+  UI_BUTTON, UI_CHECK_BUTTON,
+  UI_V_SLIDER, UI_H_SLIDER, UI_NUM_ENTRY,
+  UI_V_BARGRAPH, UI_H_BARGRAPH,
+  UI_END_GROUP, UI_V_GROUP, UI_H_GROUP, UI_T_GROUP
+};
+
+struct ui_elem_t {
+  ui_elem_type_t type;
+  char *label;
+  float *zone;
+  float init, min, max, step;
+};
+
+class PdUI : public UI
+{
+public:
+  const char *name;
+  int nelems, level;
+  ui_elem_t *elems;
+		
+  PdUI();
+  PdUI(const char *nm, const char *s);
+  virtual ~PdUI();
+
+protected:
+  std::string path;
+  void add_elem(ui_elem_type_t type, const char *label = NULL);
+  void add_elem(ui_elem_type_t type, const char *label, float *zone);
+  void add_elem(ui_elem_type_t type, const char *label, float *zone,
+		float init, float min, float max, float step);
+  void add_elem(ui_elem_type_t type, const char *label, float *zone,
+		float min, float max);
+
+public:
+  virtual void addButton(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);
+
+  virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max);
+  virtual void addVerticalBargraph(const char* label, float* zone, float min, float max);
+    
+  virtual void addSoundfile(const char* label, const char* filename, Soundfile** sf_zone) {}
+  
+  virtual void openTabBox(const char* label);
+  virtual void openHorizontalBox(const char* label);
+  virtual void openVerticalBox(const char* label);
+  virtual void closeBox();
+	
+  virtual void run();
+};
+
+static std::string mangle(const char *name, int level, const char *s)
+{
+  const char *s0 = s;
+  std::string t = "";
+  if (!s) return t;
+  // Get rid of bogus "0x00" labels in recent Faust revisions. Also, for
+  // backward compatibility with old Faust versions, make sure that default
+  // toplevel groups and explicit toplevel groups with an empty label are
+  // treated alike (these both return "0x00" labels in the latest Faust, but
+  // would be treated inconsistently in earlier versions).
+  if (!*s || strcmp(s, "0x00") == 0) {
+    if (level == 0)
+      // toplevel group with empty label, map to dsp name
+      s = name;
+    else
+      // empty label
+      s = "";
+  }
+  while (*s)
+    if (isalnum(*s))
+      t += *(s++);
+    else {
+      const char *s1 = s;
+      while (*s && !isalnum(*s)) ++s;
+      if (s1 != s0 && *s) t += "-";
+    }
+  return t;
+}
+
+static std::string normpath(std::string path)
+{
+  path = std::string("/")+path;
+  int pos = path.find("//");
+  while (pos >= 0) {
+    path.erase(pos, 1);
+    pos = path.find("//");
+  }
+  size_t len = path.length();
+  if (len > 1 && path[len-1] == '/')
+    path.erase(len-1, 1);
+  return path;
+}
+
+static std::string pathcat(std::string path, std::string label)
+{
+  if (path.empty())
+    return normpath(label);
+  else if (label.empty())
+    return normpath(path);
+  else
+    return normpath(path+"/"+label);
+}
+
+PdUI::PdUI()
+{
+  nelems = level = 0;
+  elems = NULL;
+  name = "";
+  path = "";
+}
+
+PdUI::PdUI(const char *nm, const char *s)
+{
+  nelems = level = 0;
+  elems = NULL;
+  name = nm?nm:"";
+  path = s?s:"";
+}
+
+PdUI::~PdUI()
+{
+  if (elems) {
+    for (int i = 0; i < nelems; i++)
+      if (elems[i].label)
+	free(elems[i].label);
+    free(elems);
+  }
+}
+
+inline void PdUI::add_elem(ui_elem_type_t type, const char *label)
+{
+  ui_elem_t *elems1 = (ui_elem_t*)realloc(elems, (nelems+1)*sizeof(ui_elem_t));
+  if (elems1)
+    elems = elems1;
+  else
+    return;
+  std::string s = pathcat(path, mangle(name, level, label));
+  elems[nelems].type = type;
+  elems[nelems].label = strdup(s.c_str());
+  elems[nelems].zone = NULL;
+  elems[nelems].init = 0.0;
+  elems[nelems].min = 0.0;
+  elems[nelems].max = 0.0;
+  elems[nelems].step = 0.0;
+  nelems++;
+}
+
+inline void PdUI::add_elem(ui_elem_type_t type, const char *label, float *zone)
+{
+  ui_elem_t *elems1 = (ui_elem_t*)realloc(elems, (nelems+1)*sizeof(ui_elem_t));
+  if (elems1)
+    elems = elems1;
+  else
+    return;
+  std::string s = pathcat(path, mangle(name, level, label));
+  elems[nelems].type = type;
+  elems[nelems].label = strdup(s.c_str());
+  elems[nelems].zone = zone;
+  elems[nelems].init = 0.0;
+  elems[nelems].min = 0.0;
+  elems[nelems].max = 1.0;
+  elems[nelems].step = 1.0;
+  nelems++;
+}
+
+inline void PdUI::add_elem(ui_elem_type_t type, const char *label, float *zone,
+			  float init, float min, float max, float step)
+{
+  ui_elem_t *elems1 = (ui_elem_t*)realloc(elems, (nelems+1)*sizeof(ui_elem_t));
+  if (elems1)
+    elems = elems1;
+  else
+    return;
+  std::string s = pathcat(path, mangle(name, level, label));
+  elems[nelems].type = type;
+  elems[nelems].label = strdup(s.c_str());
+  elems[nelems].zone = zone;
+  elems[nelems].init = init;
+  elems[nelems].min = min;
+  elems[nelems].max = max;
+  elems[nelems].step = step;
+  nelems++;
+}
+
+inline void PdUI::add_elem(ui_elem_type_t type, const char *label, float *zone,
+			  float min, float max)
+{
+  ui_elem_t *elems1 = (ui_elem_t*)realloc(elems, (nelems+1)*sizeof(ui_elem_t));
+  if (elems1)
+    elems = elems1;
+  else
+    return;
+  std::string s = pathcat(path, mangle(name, level, label));
+  elems[nelems].type = type;
+  elems[nelems].label = strdup(s.c_str());
+  elems[nelems].zone = zone;
+  elems[nelems].init = 0.0;
+  elems[nelems].min = min;
+  elems[nelems].max = max;
+  elems[nelems].step = 0.0;
+  nelems++;
+}
+
+void PdUI::addButton(const char* label, float* zone)
+{ add_elem(UI_BUTTON, label, zone); }
+void PdUI::addCheckButton(const char* label, float* zone)
+{ add_elem(UI_CHECK_BUTTON, label, zone); }
+void PdUI::addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step)
+{ add_elem(UI_V_SLIDER, label, zone, init, min, max, step); }
+void PdUI::addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step)
+{ add_elem(UI_H_SLIDER, label, zone, init, min, max, step); }
+void PdUI::addNumEntry(const char* label, float* zone, float init, float min, float max, float step)
+{ add_elem(UI_NUM_ENTRY, label, zone, init, min, max, step); }
+
+void PdUI::addHorizontalBargraph(const char* label, float* zone, float min, float max)
+{ add_elem(UI_H_BARGRAPH, label, zone, min, max); }
+void PdUI::addVerticalBargraph(const char* label, float* zone, float min, float max)
+{ add_elem(UI_V_BARGRAPH, label, zone, min, max); }
+
+void PdUI::openTabBox(const char* label)
+{
+  if (!path.empty()) path += "/";
+  path += mangle(name, level, label);
+  level++;
+}
+void PdUI::openHorizontalBox(const char* label)
+{
+  if (!path.empty()) path += "/";
+  path += mangle(name, level, label);
+  level++;
+}
+void PdUI::openVerticalBox(const char* label)
+{
+  if (!path.empty()) path += "/";
+  path += mangle(name, level, label);
+  level++;
+}
+void PdUI::closeBox()
+{
+  int pos = path.rfind("/");
+  if (pos < 0) pos = 0;
+  path.erase(pos);
+  level--;
+}
+
+void PdUI::run() {}
+
+/******************************************************************************
+*******************************************************************************
+
+			    FAUST DSP
+
+*******************************************************************************
+*******************************************************************************/
+
+//----------------------------------------------------------------------------
+//  FAUST generated signal processor
+//----------------------------------------------------------------------------
+		
+<<includeclass>>
+
+#include <stdio.h>
+#include <string>
+#include "m_pd.h"
+
+#define sym(name) xsym(name)
+#define xsym(name) #name
+#define faust_setup(name) xfaust_setup(name)
+#define xfaust_setup(name) name ## _tilde_setup(void)
+
+// time for "active" toggle xfades in secs
+#define XFADE_TIME 0.1f
+
+static t_class *faust_class;
+
+struct t_faust {
+  t_object x_obj;
+#ifdef __MINGW32__
+  /* This seems to be necessary as some as yet undetermined Pd routine seems
+     to write past the end of x_obj on Windows. */
+  int fence; /* dummy field (not used) */
+#endif
+  mydsp *dsp;
+  PdUI *ui;
+  std::string *label;
+  int active, xfade, n_xfade, rate, n_in, n_out;
+  t_sample **inputs, **outputs, **buf;
+  t_outlet *out;
+  t_sample f;
+};
+
+static t_symbol *s_button, *s_checkbox, *s_vslider, *s_hslider, *s_nentry,
+  *s_vbargraph, *s_hbargraph;
+
+static inline void zero_samples(int k, int n, t_sample **out)
+{
+  for (int i = 0; i < k; i++)
+#ifdef __STDC_IEC_559__
+    /* IEC 559 a.k.a. IEEE 754 floats can be initialized faster like this */
+    memset(out[i], 0, n*sizeof(t_sample));
+#else
+    for (int j = 0; j < n; j++)
+      out[i][j] = 0.0f;
+#endif
+}
+
+static inline void copy_samples(int k, int n, t_sample **out, t_sample **in)
+{
+  for (int i = 0; i < k; i++)
+    memcpy(out[i], in[i], n*sizeof(t_sample));
+}
+
+static t_int *faust_perform(t_int *w)
+{
+  t_faust *x = (t_faust *)(w[1]);
+  int n = (int)(w[2]);
+  if (!x->dsp || !x->buf) return (w+3);
+  AVOIDDENORMALS;
+  if (x->xfade > 0) {
+    float d = 1.0f/x->n_xfade, f = (x->xfade--)*d;
+    d = d/n;
+    x->dsp->compute(n, x->inputs, x->buf);
+    if (x->active)
+      if (x->n_in == x->n_out)
+	/* xfade inputs -> buf */
+	for (int j = 0; j < n; j++, f -= d)
+	  for (int i = 0; i < x->n_out; i++)
+	    x->outputs[i][j] = f*x->inputs[i][j]+(1.0f-f)*x->buf[i][j];
+      else
+	/* xfade 0 -> buf */
+	for (int j = 0; j < n; j++, f -= d)
+	  for (int i = 0; i < x->n_out; i++)
+	    x->outputs[i][j] = (1.0f-f)*x->buf[i][j];
+    else
+      if (x->n_in == x->n_out)
+	/* xfade buf -> inputs */
+	for (int j = 0; j < n; j++, f -= d)
+	  for (int i = 0; i < x->n_out; i++)
+	    x->outputs[i][j] = f*x->buf[i][j]+(1.0f-f)*x->inputs[i][j];
+      else
+	/* xfade buf -> 0 */
+	for (int j = 0; j < n; j++, f -= d)
+	  for (int i = 0; i < x->n_out; i++)
+	    x->outputs[i][j] = f*x->buf[i][j];
+  } else if (x->active) {
+    x->dsp->compute(n, x->inputs, x->buf);
+    copy_samples(x->n_out, n, x->outputs, x->buf);
+  } else if (x->n_in == x->n_out) {
+    copy_samples(x->n_out, n, x->buf, x->inputs);
+    copy_samples(x->n_out, n, x->outputs, x->buf);
+  } else
+    zero_samples(x->n_out, n, x->outputs);
+  return (w+3);
+}
+
+static void faust_dsp(t_faust *x, t_signal **sp)
+{
+  int n = sp[0]->s_n, sr = (int)sp[0]->s_sr;
+  if (x->rate <= 0) {
+    /* default sample rate is whatever Pd tells us */
+    PdUI *ui = x->ui;
+    float *z = NULL;
+    if (ui->nelems > 0 &&
+	(z = (float*)malloc(ui->nelems*sizeof(float)))) {
+      /* save the current control values */
+      for (int i = 0; i < ui->nelems; i++)
+	if (ui->elems[i].zone)
+	  z[i] = *ui->elems[i].zone;
+    }
+    /* set the proper sample rate; this requires reinitializing the dsp */
+    x->rate = sr;
+    x->dsp->init(sr);
+    if (z) {
+      /* restore previous control values */
+      for (int i = 0; i < ui->nelems; i++)
+	if (ui->elems[i].zone)
+	  *ui->elems[i].zone = z[i];
+      free(z);
+    }
+  }
+  if (n > 0)
+    x->n_xfade = (int)(x->rate*XFADE_TIME/n);
+  dsp_add(faust_perform, 2, x, n);
+  for (int i = 0; i < x->n_in; i++)
+    x->inputs[i] = sp[i+1]->s_vec;
+  for (int i = 0; i < x->n_out; i++)
+    x->outputs[i] = sp[x->n_in+i+1]->s_vec;
+  if (x->buf != NULL)
+    for (int i = 0; i < x->n_out; i++) {
+      x->buf[i] = (t_sample*)malloc(n*sizeof(t_sample));
+      if (x->buf[i] == NULL) {
+	for (int j = 0; j < i; j++)
+	  free(x->buf[j]);
+	free(x->buf);
+	x->buf = NULL;
+	break;
+      }
+    }
+}
+
+static int pathcmp(const char *s, const char *t)
+{
+  int n = strlen(s), m = strlen(t);
+  if (n == 0 || m == 0)
+    return 0;
+  else if (t[0] == '/')
+    return strcmp(s, t);
+  else if (n <= m || s[n-m-1] != '/')
+    return strcmp(s+1, t);
+  else
+    return strcmp(s+n-m, t);
+}
+
+static void faust_any(t_faust *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if (!x->dsp) return;
+  PdUI *ui = x->ui;
+  if (s == &s_bang) {
+    for (int i = 0; i < ui->nelems; i++)
+      if (ui->elems[i].label && ui->elems[i].zone) {
+	t_atom args[6];
+	t_symbol *_s;
+	switch (ui->elems[i].type) {
+	case UI_BUTTON:
+	  _s = s_button;
+	  break;
+	case UI_CHECK_BUTTON:
+	  _s = s_checkbox;
+	  break;
+	case UI_V_SLIDER:
+	  _s = s_vslider;
+	  break;
+	case UI_H_SLIDER:
+	  _s = s_hslider;
+	  break;
+	case UI_NUM_ENTRY:
+	  _s = s_nentry;
+	  break;
+	case UI_V_BARGRAPH:
+	  _s = s_vbargraph;
+	  break;
+	case UI_H_BARGRAPH:
+	  _s = s_hbargraph;
+	  break;
+	default:
+	  continue;
+	}
+	SETSYMBOL(&args[0], gensym(ui->elems[i].label));
+	SETFLOAT(&args[1], *ui->elems[i].zone);
+	SETFLOAT(&args[2], ui->elems[i].init);
+	SETFLOAT(&args[3], ui->elems[i].min);
+	SETFLOAT(&args[4], ui->elems[i].max);
+	SETFLOAT(&args[5], ui->elems[i].step);
+	outlet_anything(x->out, _s, 6, args);
+      }
+  } else {
+    const char *label = s->s_name;
+    int count = 0;
+    for (int i = 0; i < ui->nelems; i++)
+      if (ui->elems[i].label &&
+	  pathcmp(ui->elems[i].label, label) == 0) {
+	if (argc == 0) {
+	  if (ui->elems[i].zone) {
+	    t_atom arg;
+	    SETFLOAT(&arg, *ui->elems[i].zone);
+	    outlet_anything(x->out, gensym(ui->elems[i].label), 1, &arg);
+	  }
+	  ++count;
+	} else if (argc == 1 &&
+		   (argv[0].a_type == A_FLOAT ||
+		    argv[0].a_type == A_DEFFLOAT) &&
+		   ui->elems[i].zone) {
+	  float f = atom_getfloat(argv);
+	  *ui->elems[i].zone = f;
+	  ++count;
+	} else
+	  pd_error(x, "[faust] %s: bad control argument: %s",
+		   x->label->c_str(), label);
+      }
+    if (count == 0 && strcmp(label, "active") == 0) {
+      if (argc == 0) {
+	t_atom arg;
+	SETFLOAT(&arg, (float)x->active);
+	outlet_anything(x->out, gensym((char*)"active"), 1, &arg);
+      } else if (argc == 1 &&
+		 (argv[0].a_type == A_FLOAT ||
+		  argv[0].a_type == A_DEFFLOAT)) {
+	float f = atom_getfloat(argv);
+	x->active = (int)f;
+	x->xfade = x->n_xfade;
+      }
+    }
+  }
+}
+
+static void faust_free(t_faust *x)
+{
+  if (x->label) delete x->label;
+  if (x->dsp) delete x->dsp;
+  if (x->ui) delete x->ui;
+  if (x->inputs) free(x->inputs);
+  if (x->outputs) free(x->outputs);
+  if (x->buf) {
+    for (int i = 0; i < x->n_out; i++)
+      if (x->buf[i]) free(x->buf[i]);
+    free(x->buf);
+  }
+}
+
+static void *faust_new(t_symbol *s, int argc, t_atom *argv)
+{
+  t_faust *x = (t_faust*)pd_new(faust_class);
+  int sr = -1;
+  t_symbol *id = NULL;
+  x->active = 1;
+  for (int i = 0; i < argc; i++)
+    if (argv[i].a_type == A_FLOAT || argv[i].a_type == A_DEFFLOAT)
+      sr = (int)argv[i].a_w.w_float;
+    else if (argv[i].a_type == A_SYMBOL || argv[i].a_type == A_DEFSYMBOL)
+      id = argv[i].a_w.w_symbol;
+  x->rate = sr;
+  if (sr <= 0) sr = 44100;
+  x->xfade = 0; x->n_xfade = (int)(sr*XFADE_TIME/64);
+  x->inputs = x->outputs = x->buf = NULL;
+    x->label = new std::string(sym(mydsp) "~");
+  x->dsp = new mydsp();
+  x->ui = new PdUI(sym(mydsp), id?id->s_name:NULL);
+  if (!x->dsp || !x->ui || !x->label) goto error;
+  if (id) {
+    *x->label += " ";
+    *x->label += id->s_name;
+  }
+  x->n_in = x->dsp->getNumInputs();
+  x->n_out = x->dsp->getNumOutputs();
+  if (x->n_in > 0)
+    x->inputs = (t_sample**)malloc(x->n_in*sizeof(t_sample*));
+  if (x->n_out > 0) {
+    x->outputs = (t_sample**)malloc(x->n_out*sizeof(t_sample*));
+    x->buf = (t_sample**)malloc(x->n_out*sizeof(t_sample*));
+  }
+  if ((x->n_in > 0 && x->inputs == NULL) ||
+      (x->n_out > 0 && (x->outputs == NULL || x->buf == NULL)))
+    goto error;
+  for (int i = 0; i < x->n_out; i++)
+    x->buf[i] = NULL;
+  x->dsp->init(sr);
+  x->dsp->buildUserInterface(x->ui);
+  for (int i = 0; i < x->n_in; i++)
+    inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
+  x->out = outlet_new(&x->x_obj, 0);
+  for (int i = 0; i < x->n_out; i++)
+    outlet_new(&x->x_obj, &s_signal);
+  return (void *)x;
+ error:
+  faust_free(x);
+  x->dsp = NULL; x->ui = NULL;
+  x->inputs = x->outputs = x->buf = NULL;
+  return (void *)x;
+}
+
+extern "C" void faust_setup(mydsp)
+{
+  t_symbol *s = gensym(sym(mydsp) "~");
+  faust_class =
+    class_new(s, (t_newmethod)faust_new, (t_method)faust_free,
+	      sizeof(t_faust), CLASS_DEFAULT,
+	      A_GIMME, A_NULL);
+  class_addmethod(faust_class, (t_method)faust_dsp, gensym((char*)"dsp"), A_NULL);
+  class_addanything(faust_class, faust_any);
+  class_addmethod(faust_class, nullfn, &s_signal, A_NULL);
+  s_button = gensym((char*)"button");
+  s_checkbox = gensym((char*)"checkbox");
+  s_vslider = gensym((char*)"vslider");
+  s_hslider = gensym((char*)"hslider");
+  s_nentry = gensym((char*)"nentry");
+  s_vbargraph = gensym((char*)"vbargraph");
+  s_hbargraph = gensym((char*)"hbargraph");
+  /* give some indication that we're loaded and ready to go */
+  mydsp dsp = mydsp();
+  post("[faust] %s: %d inputs, %d outputs", sym(mydsp) "~",
+       dsp.getNumInputs(), dsp.getNumOutputs());
+}