--- /dev/null
+/* octave.cpp
+ Copyright (C) 2009 by Bjoern Anton Erlach. */
+
+// OCTAVE architecture file for faust.
+//
+// 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., 59 Temple Place, Suite 330, Boston, MA
+// 02111-1307 USA
+//-------------------------------------------------------------------
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <math.h>
+#include <errno.h>
+#include <time.h>
+#include <vector>
+#include <string>
+#include <map>
+#include <iostream>
+#include <oct.h>
+
+
+using namespace std;
+
+// TODO: find out what to do with this Meta thing
+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>>
+
+/******************************************************************************
+*******************************************************************************
+
+ ABSTRACT USER INTERFACE
+
+*******************************************************************************
+*******************************************************************************/
+
+
+class UI
+{
+ bool fStopped;
+public:
+
+ UI() : fStopped(false) {}
+ virtual ~UI() {}
+
+ // -- 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;
+
+ // -- frames and labels
+
+ 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 show() = 0;
+ virtual void run() = 0;
+
+ void stop() { fStopped = true; }
+ bool stopped() { return fStopped; }
+
+ virtual void declare(float* zone, const char* key, const char* value) {}
+};
+
+
+struct param {
+ string fName; float *fVals; float* fZone; float fMin; float fMax;
+ param(string name, float* z, float init, float a, float b) : fName(name), fVals(NULL), fZone(z), fMin(a), fMax(b) { *z = init; }
+};
+
+
+class FNUI : public UI
+{
+ vector<param> fParam;
+ int numOptions;
+
+
+public:
+ FNUI() : UI() { numOptions=0; }
+ virtual ~FNUI() {}
+
+
+ void addOption(const char* label, float* zone, float init, float min, float max)
+ {
+ string fullname = label;
+ fParam.push_back(param(fullname, zone, init, min, max));
+ numOptions++;
+ }
+
+ virtual vector<param> getOpts () { return fParam; }
+
+ virtual void addButton(const char* label, float* zone)
+ {
+ addOption(label,zone,0,0,1);
+ }
+
+ virtual int getNumOptions() { return numOptions; }
+
+ virtual void addToggleButton(const char* label, float* zone)
+ {
+ addOption(label,zone,0,0,1);
+ }
+
+ virtual void addCheckButton(const char* label, float* zone)
+ {
+ addOption(label,zone,0,0,1);
+ }
+
+ virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step)
+ {
+ addOption(label,zone,init,min,max);
+ }
+
+ virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step)
+ {
+ addOption(label,zone,init,min,max);
+ }
+
+ virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step)
+ {
+ addOption(label,zone,init,min,max);
+ }
+
+ // -- 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) {}
+
+
+ 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 openFrameBox(const char* label) { openAnyBox(label); }
+ //virtual void openTabBox(const char* label) { openAnyBox(label); }
+ //virtual void openHorizontalBox(const char* label) { openAnyBox(label); }
+ //virtual void openVerticalBox(const char* label) { openAnyBox(label); }
+
+ //virtual void closeBox() { fPrefix.pop(); }
+ virtual void closeBox() { }
+ virtual void run() {}
+ virtual void show() {}
+
+};
+
+
+
+/******************************************************************************
+*******************************************************************************
+
+ FAUST DSP
+
+*******************************************************************************
+*******************************************************************************/
+
+
+
+//----------------------------------------------------------------
+// abstract definition of a signal processor
+//----------------------------------------------------------------
+
+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;
+};
+
+
+//----------------------------------------------------------------------------
+// FAUST generated signal processor
+//----------------------------------------------------------------------------
+
+
+<<includeclass>>
+
+
+//----------------------------------------------------------------------------
+// Octave interface
+//----------------------------------------------------------------------------
+
+// Prefered way to allocate memory
+#define ALLOC(x) alloca(x)
+#define FREE(x) ((void)0)
+// if ALLOCA is not available use MALLOC
+//#define ALLOC(x) malloc(x)
+//#define FREE(x) free(x)
+
+#define QUOTEME(x) #x
+
+#define DEFAULT_SAMPLERATE 44100
+#define DEFAULT_BLOCKSIZE 64
+
+// linear interpolation for vector valued control inputs
+void
+interpolate_ctrlin (float *vals, NDArray in, int n)
+{
+ int nin = in.length();
+ double ratio = (double)(n-1)/(double)(nin-1);
+ int irat = (int) ratio;
+ double frat = ratio - (double) irat;
+ double rest = 0;
+ int i = 0;
+ float x;
+
+ for (int j=0; j<(nin-1); j++) {
+ float del;
+ int seglength = irat;
+ rest += frat;
+ if (rest >= 1.0) {
+ seglength ++;
+ rest -= 1.0;
+ }
+ del = (in(j+1) - in(j)) / (float) seglength;
+ x = in(j);
+ for (int k=0; k<seglength; k++) {
+ vals[i++] = x;
+ x += del;
+ }
+ }
+ for (; i<n; i++) {
+ vals[i] = in(nin-1);
+ }
+}
+
+
+
+DEFUN_DLD (FAUST_FUNC_NAME, args, nargout,
+ "type " QUOTEME(FAUST_FUNC_NAME) "() to see the arguments.\n")
+{
+ int nargin = args.length();
+ int numIn;
+ int numOut;
+ int numOpts;
+ int maxInputLength = 0;
+ mydsp DSP;
+ int ngivenctrls;
+ float **finputs;
+ float **foutputs;
+ float **controlinputs;
+ int ctrllength;
+ int ctrlargoff;
+ int allscalarctrls = 1;
+ // TODO: float **controloutputs;
+ int i;
+ vector<param> opts;
+ int bsize;
+ int srate;
+ octave_value_list retval;
+ octave_value tmp;
+
+ FNUI* interface = new FNUI();
+ DSP.buildUserInterface(interface);
+
+ // check if global variable FAUST_BLOCKSIZE is set.
+ tmp = get_global_value ("FAUST_BLOCKSIZE", true);
+ if (tmp.is_defined ())
+ bsize = (int) tmp.scalar_value();
+ else {
+ bsize = DEFAULT_BLOCKSIZE;
+ }
+
+ // check if global variable FAUST_SAMPLERATE is set.
+ tmp = get_global_value ("FAUST_SAMPLERATE", true);
+ if (tmp.is_defined ())
+ srate = (int) tmp.scalar_value();
+ else {
+ srate = DEFAULT_SAMPLERATE;
+ }
+
+ DSP.init(srate);
+ opts = interface->getOpts();
+
+ numIn = DSP.getNumInputs();
+ numOut = DSP.getNumOutputs();
+ numOpts = interface->getNumOptions();
+
+ // print a usage message in case the function is called with too few arguments
+ if (nargin < numIn || nargin == 0) {
+ if (numOut>1) {
+ octave_stdout << "[out1";
+ for (i=2; i<=numOut; i++)
+ octave_stdout << ",out" << i;
+ octave_stdout << "] = " << QUOTEME(FAUST_FUNC_NAME) << "(";
+ } else {
+ octave_stdout << "out = " << QUOTEME(FAUST_FUNC_NAME) << "(";
+ }
+ if (numIn == 0)
+ octave_stdout << "numsamps";
+ else
+ octave_stdout << "in1";
+ for (i=2; i<=numIn; i++)
+ octave_stdout << ", in" << i;
+ for (i=0; i<numOpts; i++)
+ octave_stdout << ", " << opts[i].fName;
+ octave_stdout << ")\n";
+ delete interface;
+ return retval;
+ }
+
+ // If we have inputs we use the length of the longest input vector
+ // as length of the output to be produced.
+ // If we don't have inputs, the first argument specifies the number of
+ // samples to be produced.
+ if (numIn == 0) {
+ maxInputLength = args(0).scalar_value();
+ ctrlargoff = 1;
+ } else {
+ ctrlargoff = numIn;
+ for (i=0; i<numIn; i++) {
+ octave_idx_type nr = args(i).matrix_value().rows();
+ octave_idx_type nc = args(i).matrix_value().columns();
+ if (nr == 1) {
+ if (nc > maxInputLength)
+ maxInputLength = nc;
+ } else if (nc == 1) {
+ if (nr > maxInputLength)
+ maxInputLength = nr;
+ } else {
+ maxInputLength = nc;
+ octave_stdout << "Argument " << i << " has wrong dimensions " << nr << "x" << nc << "\n";
+ }
+ }
+ }
+
+
+ ctrllength = (maxInputLength+bsize-1)/bsize;
+
+ // check for arguments that should serve as control inputs
+ for (i=ctrlargoff; i<nargin; i++) {
+ if ((i-ctrlargoff) < numOpts) {
+ NDArray v = args(i).array_value();
+ if (v.length() > 1) {
+ allscalarctrls = 0;
+ opts[i-ctrlargoff].fVals = (float*) ALLOC(sizeof(float)*ctrllength);
+ interpolate_ctrlin(opts[i-ctrlargoff].fVals, v, ctrllength);
+ *opts[i-ctrlargoff].fZone = (float) v(0);
+ } else {
+ *opts[i-ctrlargoff].fZone = (float) args(i).scalar_value();
+ }
+ }
+ }
+
+ for (i=0; i<numOpts; i++) {
+ octave_stdout << "Parameter " << opts[i].fName << ": " << *opts[i].fZone << "\n";
+ }
+
+ finputs = (float**) ALLOC(sizeof(float*) * numIn);
+ foutputs = (float**) ALLOC(sizeof(float*) * numOut);
+
+ // Copy the matrix and convert to floats - This is a real slowdown!
+ for (i=0; i<numIn; i++) {
+ Matrix m = args(i).matrix_value();
+ float *p;
+ finputs[i] = (float*) ALLOC(maxInputLength * sizeof(float));
+ memset(finputs[i], 0, sizeof(float)*maxInputLength);
+ p = finputs[i];
+ if (m.rows() > m.columns()) {
+ for (int j=0; j<m.rows(); j++) {
+ *p++ = (float) m(j,0);
+ }
+ } else {
+ for (int j=0; j<m.columns(); j++) {
+ *p++ = (float) m(0,j);
+ }
+ }
+ }
+
+ // allocate output vectors
+ for (i=0; i<numOut; i++) {
+ foutputs[i] = (float*) ALLOC(maxInputLength * sizeof(float));
+ memset(foutputs[i], 0, sizeof(float)*maxInputLength);
+ }
+
+ if (allscalarctrls) {
+ DSP.compute(maxInputLength, finputs, foutputs);
+ } else {
+ int nleft = maxInputLength;
+ int k = 0;
+ float **fins;
+ float **fouts;
+ fins = (float**) ALLOC(sizeof(float*) * numIn);
+ fouts = (float**) ALLOC(sizeof(float*) * numOut);
+ memcpy(fins, finputs, sizeof(float*)*numIn);
+ memcpy(fouts, foutputs, sizeof(float*)*numOut);
+ while (nleft > 0) {
+ int n = min(bsize, nleft);
+ for (i=0; i<numOpts; i++) {
+ if (opts[i].fVals) {
+ *opts[i].fZone = opts[i].fVals[k];
+ }
+ }
+ DSP.compute(n, fins, fouts);
+ nleft -= n;
+ k++;
+ for (i=0; i<numIn; i++)
+ fins[i] += n;
+ for (i=0; i<numOut; i++)
+ fouts[i] += n;
+ }
+ FREE(fins);
+ FREE(fouts);
+ }
+
+ // copy the output from the float arrays (and free all tmp memory if malloc is used)
+ for (i=0; i<numOut; i++) {
+ Matrix output = Matrix(1, maxInputLength);
+ for (int j=0; j<maxInputLength; j++)
+ output(0, j) = (double) foutputs[i][j];
+ FREE(foutputs[i]);
+ retval(i) = output;
+ }
+ for (i=0; i<numOpts; i++) {
+ if (opts[i].fVals) {
+ FREE(opts[i].fVals);
+ }
+ }
+ for (i=0; i<numIn; i++) {
+ FREE(finputs[i]);
+ }
+ FREE(foutputs);
+ FREE(finputs);
+
+ delete interface;
+ return retval;
+}
projects / Faustine.git / blobdiff