interpretor/preprocessor/faust-0.9.47mr3/architecture/matlabplot.cpp

   1 /************************************************************************
   2  ************************************************************************
   3     FAUST Architecture File
   4         Copyright (C) 2007-2011 Julius O. Smith III
   5     ---------------------------------------------------------------------
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU Lesser General Public License as
   8         published by the Free Software Foundation; either version 2.1 of the
   9         License, or (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU Lesser General Public License for more details.
  15
  16     You should have received a copy of the GNU Lesser General Public
  17         License along with the GNU C Library; if not, write to the Free
  18         Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19         02111-1307 USA.
  20  ************************************************************************
  21  ************************************************************************/
  22
  23 /* matlabplot.cpp = simple variation of plot.cpp */
  24 #include <assert.h>
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <limits.h>
  29 #include <math.h>
  30 #include <errno.h>
  31 #include <time.h>
  32 #include <ctype.h>
  33
  34 #include <vector>
  35 #include <stack>
  36 #include <string>
  37 #include <map>
  38 #include <list>
  39 #include <iostream>
  40
  41 // g++ -O3 -lm -lsndfile  myfx.cpp
  42
  43 using namespace std;
  44
  45 struct Meta : map<const char*, const char*>
  46 {
  47     void declare (const char* key, const char* value) { (*this)[key]=value; }
  48 };
  49
  50
  51 //-------------------------------------------------------------------
  52 // Generic min and max using c++ inline
  53 //-------------------------------------------------------------------
  54
  55 inline int              max (unsigned int a, unsigned int b) { return (a>b) ? a : b; }
  56 inline int              max (int a, int b)                      { return (a>b) ? a : b; }
  57
  58 inline long     max (long a, long b)            { return (a>b) ? a : b; }
  59 inline long     max (int a, long b)             { return (a>b) ? a : b; }
  60 inline long     max (long a, int b)             { return (a>b) ? a : b; }
  61
  62 inline float    max (float a, float b)          { return (a>b) ? a : b; }
  63 inline float    max (int a, float b)            { return (a>b) ? a : b; }
  64 inline float    max (float a, int b)            { return (a>b) ? a : b; }
  65 inline float    max (long a, float b)           { return (a>b) ? a : b; }
  66 inline float    max (float a, long b)           { return (a>b) ? a : b; }
  67
  68 inline double   max (double a, double b)        { return (a>b) ? a : b; }
  69 inline double   max (int a, double b)           { return (a>b) ? a : b; }
  70 inline double   max (double a, int b)           { return (a>b) ? a : b; }
  71 inline double   max (long a, double b)          { return (a>b) ? a : b; }
  72 inline double   max (double a, long b)          { return (a>b) ? a : b; }
  73 inline double   max (float a, double b)         { return (a>b) ? a : b; }
  74 inline double   max (double a, float b)         { return (a>b) ? a : b; }
  75
  76
  77 inline int              min (int a, int b)                      { return (a<b) ? a : b; }
  78
  79 inline long     min (long a, long b)            { return (a<b) ? a : b; }
  80 inline long     min (int a, long b)             { return (a<b) ? a : b; }
  81 inline long     min (long a, int b)             { return (a<b) ? a : b; }
  82
  83 inline float    min (float a, float b)          { return (a<b) ? a : b; }
  84 inline float    min (int a, float b)            { return (a<b) ? a : b; }
  85 inline float    min (float a, int b)            { return (a<b) ? a : b; }
  86 inline float    min (long a, float b)           { return (a<b) ? a : b; }
  87 inline float    min (float a, long b)           { return (a<b) ? a : b; }
  88
  89 inline double   min (double a, double b)        { return (a<b) ? a : b; }
  90 inline double   min (int a, double b)           { return (a<b) ? a : b; }
  91 inline double   min (double a, int b)           { return (a<b) ? a : b; }
  92 inline double   min (long a, double b)          { return (a<b) ? a : b; }
  93 inline double   min (double a, long b)          { return (a<b) ? a : b; }
  94 inline double   min (float a, double b)         { return (a<b) ? a : b; }
  95 inline double   min (double a, float b)         { return (a<b) ? a : b; }
  96
  97
  98
  99 inline int              lsr (int x, int n)                      { return int(((unsigned int)x) >> n); }
 100
 101 template<typename T> T abs (T a)                        { return (a<T(0)) ? -a : a; }
 102
 103
 104 /******************************************************************************
 105 *******************************************************************************
 106
 107                                                                VECTOR INTRINSICS
 108
 109 *******************************************************************************
 110 *******************************************************************************/
 111
 112 <<includeIntrinsic>>
 113
 114
 115
 116
 117 /******************************************************************************
 118 *******************************************************************************
 119
 120                                                         USER INTERFACE
 121
 122 *******************************************************************************
 123 *******************************************************************************/
 124
 125 class UI
 126 {
 127     bool        fStopped;
 128 public:
 129
 130     UI() : fStopped(false) {}
 131     virtual ~UI() {}
 132
 133     // -- active widgets
 134
 135     virtual void addButton(const char* label, float* zone) = 0;
 136     virtual void addToggleButton(const char* label, float* zone) = 0;
 137     virtual void addCheckButton(const char* label, float* zone) = 0;
 138     virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step) = 0;
 139     virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step) = 0;
 140     virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step) = 0;
 141
 142     // -- passive widgets
 143
 144     virtual void addNumDisplay(const char* label, float* zone, int precision) = 0;
 145     virtual void addTextDisplay(const char* label, float* zone, char* names[], float min, float max) = 0;
 146     virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max) = 0;
 147     virtual void addVerticalBargraph(const char* label, float* zone, float min, float max) = 0;
 148
 149     // -- frames and labels
 150
 151     virtual void openFrameBox(const char* label) = 0;
 152     virtual void openTabBox(const char* label) = 0;
 153     virtual void openHorizontalBox(const char* label) = 0;
 154     virtual void openVerticalBox(const char* label) = 0;
 155     virtual void closeBox() = 0;
 156
 157     virtual void show() = 0;
 158     virtual void run() = 0;
 159
 160     void stop()         { fStopped = true; }
 161     bool stopped()      { return fStopped; }
 162
 163     virtual void declare(float* zone, const char* key, const char* value) {}
 164 };
 165
 166 struct param {
 167     float* fZone;
 168     float fMin;
 169     float fMax;
 170     param(float* z, float init, float a, float b) : fZone(z), fMin(a), fMax(b) { *z = init; }
 171 };
 172
 173
 174 class CMDUI : public UI
 175 {
 176     int                                 fArgc;
 177     char**                              fArgv;
 178     vector<char*>               fFiles;
 179     stack<string>               fPrefix;
 180     map<string, param>  fKeyParam;
 181
 182     void openAnyBox(const char* label)
 183     {
 184         string prefix;
 185
 186         if (label && label[0]) {
 187             prefix = fPrefix.top() + "-" + label;
 188         } else {
 189             prefix = fPrefix.top();
 190         }
 191         fPrefix.push(prefix);
 192     }
 193
 194     string simplify(const string& src)
 195     {
 196         int             i=0;
 197         int             level=0;
 198         string  dst;
 199
 200         while (src[i] ) {
 201
 202             switch (level) {
 203
 204                 case 0 :
 205                 case 1 :
 206                 case 2 :
 207                     // Skip the begin of the label "--foo-"
 208                     // until 3 '-' have been read
 209                     if (src[i]=='-') { level++; }
 210                     break;
 211
 212                 case 3 :
 213                     // copy the content, but skip non alphnum
 214                     // and content in parenthesis
 215                     switch (src[i]) {
 216                         case '(' :
 217                         case '[' :
 218                             level++;
 219                             break;
 220
 221                         case '-' :
 222                             dst += '-';
 223                             break;
 224
 225                         default :
 226                             if (isalnum(src[i])) {
 227                                 dst+= tolower(src[i]);
 228                             }
 229
 230                     }
 231                     break;
 232
 233                 default :
 234                     // here we are inside parenthesis and
 235                     // we skip the content until we are back to
 236                     // level 3
 237                     switch (src[i]) {
 238
 239                         case '(' :
 240                         case '[' :
 241                             level++;
 242                             break;
 243
 244                         case ')' :
 245                         case ']' :
 246                             level--;
 247                             break;
 248
 249                         default :
 250                             break;
 251                     }
 252
 253             }
 254             i++;
 255         }
 256         return dst;
 257     }
 258
 259
 260 public:
 261
 262     CMDUI(int argc, char *argv[]) : UI(), fArgc(argc), fArgv(argv) { fPrefix.push("-"); }
 263     virtual ~CMDUI() {}
 264
 265
 266     void addOption(const char* label, float* zone, float init, float min, float max)
 267     {
 268         string fullname = "-" + simplify(fPrefix.top() + "-" + label);
 269         fKeyParam.insert(make_pair(fullname, param(zone, init, min, max)));
 270     }
 271
 272
 273     virtual void addButton(const char* label, float* zone)
 274     {
 275         addOption(label,zone,0,0,1);
 276     }
 277
 278     virtual void addToggleButton(const char* label, float* zone)
 279     {
 280         addOption(label,zone,0,0,1);
 281     }
 282
 283     virtual void addCheckButton(const char* label, float* zone)
 284     {
 285         addOption(label,zone,0,0,1);
 286     }
 287
 288     virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step)
 289     {
 290         addOption(label,zone,init,min,max);
 291     }
 292
 293     virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step)
 294     {
 295         addOption(label,zone,init,min,max);
 296     }
 297
 298     virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step)
 299     {
 300         addOption(label,zone,init,min,max);
 301     }
 302
 303     // -- passive widgets
 304
 305     virtual void addNumDisplay(const char* label, float* zone, int precision)                                           {}
 306     virtual void addTextDisplay(const char* label, float* zone, char* names[], float min, float max)    {}
 307     virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max)                    {}
 308     virtual void addVerticalBargraph(const char* label, float* zone, float min, float max)                      {}
 309
 310     virtual void openFrameBox(const char* label)                { openAnyBox(label); }
 311     virtual void openTabBox(const char* label)                  { openAnyBox(label); }
 312     virtual void openHorizontalBox(const char* label)   { openAnyBox(label); }
 313     virtual void openVerticalBox(const char* label)             { openAnyBox(label); }
 314
 315     virtual void closeBox()                                                     { fPrefix.pop(); }
 316
 317     virtual void show() {}
 318     virtual void run()  {}
 319
 320     void printhelp()
 321     {
 322         map<string, param>::iterator i;
 323         cout << fArgc << "\n";
 324         cout << fArgv[0] << " option list : ";
 325         for (i = fKeyParam.begin(); i != fKeyParam.end(); i++) {
 326             cout << "[ " << i->first << " " << i->second.fMin << ".." << i->second.fMax <<" ] ";
 327         }
 328         cout << " infile outfile\n";
 329     }
 330
 331     void process_command()
 332     {
 333         map<string, param>::iterator p;
 334         for (int i = 1; i < fArgc; i++) {
 335             if (fArgv[i][0] == '-') {
 336                 if (    (strcmp(fArgv[i], "-help") == 0)
 337                         || (strcmp(fArgv[i], "-h") == 0)
 338                         || (strcmp(fArgv[i], "--help") == 0) )  {
 339                     printhelp();
 340                     exit(1);
 341                 }
 342                 p = fKeyParam.find(fArgv[i]);
 343                 if (p == fKeyParam.end()) {
 344                     cout << fArgv[0] << " : unrecognized option " << fArgv[i] << "\n";
 345                     printhelp();
 346                     exit(1);
 347                 }
 348                 char*   end;
 349                 *(p->second.fZone) = float(strtod(fArgv[i+1], &end));
 350                 i++;
 351             } else {
 352                 fFiles.push_back(fArgv[i]);
 353             }
 354         }
 355     }
 356
 357     int         files()                 { return fFiles.size(); }
 358     char*       file (int n)    { return fFiles[n]; }
 359
 360 };
 361
 362 //----------------------------------------------------------------
 363 //  d�inition du processeur de signal
 364 //----------------------------------------------------------------
 365
 366 class dsp {
 367 protected:
 368     int fSamplingFreq;
 369 public:
 370     dsp() {}
 371     virtual ~dsp() {}
 372
 373     virtual int getNumInputs()                                                                          = 0;
 374     virtual int getNumOutputs()                                                                         = 0;
 375     virtual void buildUserInterface(UI* interface)                                      = 0;
 376     virtual void init(int samplingRate)                                                         = 0;
 377     virtual void compute(int len, float** inputs, float** outputs)      = 0;
 378     virtual void conclude()                                                                             {}
 379 };
 380
 381
 382 //----------------------------------------------------------------------------
 383 //      FAUST generated code
 384 //----------------------------------------------------------------------------
 385
 386 <<includeclass>>
 387
 388
 389 mydsp   DSP;
 390
 391
 392 class channels
 393 {
 394     int         fNumFrames;
 395     int         fNumChannels;
 396     float*      fBuffers[256];
 397
 398 public:
 399
 400     channels(int nframes, int nchannels)
 401     {
 402                 assert(nchannels < 256);
 403
 404         fNumFrames              = nframes;
 405         fNumChannels    = nchannels;
 406
 407         // allocate audio  channels
 408         for (int i = 0; i < fNumChannels; i++) {
 409             fBuffers[i] = (float*) calloc (fNumFrames, sizeof(float));
 410         }
 411     }
 412
 413     void zero()
 414     {
 415         // allocate audio  channels
 416         for (int i = 0; i < fNumChannels; i++) {
 417                         for (int f = 0; f < fNumFrames; f++) {
 418                                 fBuffers[i][f] = 0.0;
 419                         }
 420         }
 421     }
 422
 423     void impulse()
 424     {
 425         // allocate audio  channels
 426         for (int i = 0; i < fNumChannels; i++) {
 427                         fBuffers[i][0] = 1.0;
 428                         for (int f = 1; f < fNumFrames; f++) {
 429                                 fBuffers[i][f] = 0.0;
 430                         }
 431         }
 432     }
 433
 434     ~channels()
 435     {
 436         // free separate input channels
 437         for (int i = 0; i < fNumChannels; i++) {
 438             free(fBuffers[i]);
 439         }
 440     }
 441
 442     float**     buffers()               { return fBuffers; }
 443 };
 444
 445
 446
 447 #define kFrames 512
 448
 449 int main(int argc, char *argv[] )
 450 {
 451     float                       fStartAtSample;
 452         float                   fnbsamples;
 453
 454
 455     CMDUI* interface = new CMDUI(argc, argv);
 456     DSP.buildUserInterface(interface);
 457
 458     interface->addOption("-s", &fStartAtSample, 0, 0.0, 100000000.0);
 459         interface->addOption("-n", &fnbsamples, 16, 0.0, 100000000.0);
 460
 461 //     if (DSP.getNumInputs() > 0) {
 462 //         fprintf(stderr,
 463 //                 "*** input signals not supported by architecture file matlab.cpp\n");
 464 //         exit(1);
 465 //     }
 466
 467     // init signal processor and the user interface values:
 468     DSP.init(44100);
 469
 470     // modify the UI values according to the command-line options:
 471     interface->process_command();
 472
 473         // prepare input channels (if any) with an impulse
 474     int nins = DSP.getNumInputs();
 475     channels inchan (kFrames, nins);
 476         inchan.impulse(); // after each compute we will zero them
 477
 478         // prepare output channels
 479     int nouts = DSP.getNumOutputs();
 480     channels outchan (kFrames, nouts);
 481
 482     // print usage info:
 483     printf("%% Usage: octave --persist thisfile.m\n\n");
 484
 485     // print matlab-compatible matrix syntax followed by a plot command:
 486     printf("faustout = [ ...\n");
 487
 488
 489         // skip <start> samples
 490         int start = int(fStartAtSample);
 491         while (start > kFrames) {
 492                 DSP.compute(kFrames, inchan.buffers(), outchan.buffers());
 493                 inchan.zero();
 494                 start -= kFrames;
 495         }
 496         if (start > 0) {
 497                 DSP.compute(start, inchan.buffers(), outchan.buffers());
 498         }
 499         // end skip
 500
 501
 502         int nbsamples = int(fnbsamples);
 503     while (nbsamples > kFrames) {
 504
 505         DSP.compute(kFrames, inchan.buffers(), outchan.buffers());
 506                 inchan.zero();
 507         for (int i = 0; i < kFrames; i++) {
 508             for (int c = 0; c < nouts; c++) {
 509                 printf(" %g", outchan.buffers()[c][i]);
 510             }
 511             if (i < kFrames-1) {
 512                 printf("; ...\n");
 513             } else {
 514                 printf("; ...\n%%---- Chunk Boundary ----\n");
 515             }
 516         }
 517         nbsamples -= kFrames;
 518     }
 519
 520     if (nbsamples) { // Write out partial-chunk buffer:
 521
 522         DSP.compute(nbsamples, inchan.buffers(), outchan.buffers());
 523                 inchan.zero();
 524         for (int i = 0; i < nbsamples; i++) {
 525             for (int c = 0; c < nouts; c++) {
 526                 printf(" %g", outchan.buffers()[c][i]);
 527             }
 528             printf("; ...\n");
 529         }
 530     }
 531     printf("];\n\n");
 532     printf("plot(faustout);\n");
 533     printf("title('Plot generated by %s made using ''faust -a matlabplot.cpp ...''');\n",argv[0]);
 534     printf("xlabel('Time (samples)');\n");
 535     printf("ylabel('Amplitude');\n");
 536     if (nouts>1) {
 537         printf("legend(");
 538         for (int c = 0; c < nouts; c++) {
 539             printf("'channel %d'", c+1);
 540             if (c<nouts-1) { printf(","); }
 541         }
 542         printf(");");
 543     }
 544     return 0;
 545 }