Logo Search packages:      
Sourcecode: faust version File versions  Download package

oss-wx.cpp

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <math.h>
#include <errno.h>
#include <time.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/soundcard.h>
#include <pwd.h>
#include <sys/types.h>
#include <assert.h>
#include <pthread.h> 
#include <sys/wait.h>
#include <list>
#include <vector>
#include <stack>

#include "wx/wx.h"
#include "wx/statbox.h"
#include "wx/notebook.h"
#include "wx/spinctrl.h"

// g++ -O3 -lm `wx-config --cflags --libs` ex2.cpp

using namespace std ;
 
      
#ifdef __GNUC__

//-------------------------------------------------------------------
// Generic min and max using gcc extensions
//-------------------------------------------------------------------

#define max(x,y) ((x)>?(y))
#define min(x,y) ((x)<?(y))

//abs(x) should be already predefined

#else

//-------------------------------------------------------------------
// Generic min and max using c++ inline
//-------------------------------------------------------------------

inline int        max (unsigned int a, unsigned int b) { return (a>b) ? a : b; }
inline int        max (int a, int b)                  { return (a>b) ? a : b; }

inline long       max (long a, long b)          { return (a>b) ? a : b; }
inline long       max (int a, long b)           { return (a>b) ? a : b; }
inline long       max (long a, int b)           { return (a>b) ? a : b; }

inline float      max (float a, float b)        { return (a>b) ? a : b; }
inline float      max (int a, float b)          { return (a>b) ? a : b; }
inline float      max (float a, int b)          { return (a>b) ? a : b; }
inline float      max (long a, float b)         { return (a>b) ? a : b; }
inline float      max (float a, long b)         { return (a>b) ? a : b; }

inline double     max (double a, double b)      { return (a>b) ? a : b; }
inline double     max (int a, double b)         { return (a>b) ? a : b; }
inline double     max (double a, int b)         { return (a>b) ? a : b; }
inline double     max (long a, double b)        { return (a>b) ? a : b; }
inline double     max (double a, long b)        { return (a>b) ? a : b; }
inline double     max (float a, double b)       { return (a>b) ? a : b; }
inline double     max (double a, float b)       { return (a>b) ? a : b; }


inline int        min (int a, int b)                  { return (a<b) ? a : b; }

inline long       min (long a, long b)          { return (a<b) ? a : b; }
inline long       min (int a, long b)           { return (a<b) ? a : b; }
inline long       min (long a, int b)           { return (a<b) ? a : b; }

inline float      min (float a, float b)        { return (a<b) ? a : b; }
inline float      min (int a, float b)          { return (a<b) ? a : b; }
inline float      min (float a, int b)          { return (a<b) ? a : b; }
inline float      min (long a, float b)         { return (a<b) ? a : b; }
inline float      min (float a, long b)         { return (a<b) ? a : b; }

inline double     min (double a, double b)      { return (a<b) ? a : b; }
inline double     min (int a, double b)         { return (a<b) ? a : b; }
inline double     min (double a, int b)         { return (a<b) ? a : b; }
inline double     min (long a, double b)        { return (a<b) ? a : b; }
inline double     min (double a, long b)        { return (a<b) ? a : b; }
inline double     min (float a, double b)       { return (a<b) ? a : b; }
inline double     min (double a, float b)       { return (a<b) ? a : b; }
            
#endif

// 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); }

inline int        int2pow2 (int x)  { int r=0; while ((1<<r)<x) r++; return r; }


void setRealtimePriority ()
{
        struct passwd *         pw;
        int                     err;
        uid_t                   uid;
        struct sched_param      param;  
        
        uid = getuid ();
        pw = getpwnam ("root");
        setuid (pw->pw_uid); 
        param.sched_priority = 50; /* 0 to 99  */
        err = sched_setscheduler(0, SCHED_RR,  &param); 
        setuid (uid);
        if (err != -1) {
                printf("OK : Running with realtime priority\n");
        } else {
                printf("Warning : running with non-realtime priority\n");
        }
        
}


/******************************************************************************
*******************************************************************************

                                                 VECTOR INTRINSICS

*******************************************************************************
*******************************************************************************/


<<includeIntrinsic>>



/******************************************************************************
*******************************************************************************

                                                AUDIO INTERFACE

*******************************************************************************
*******************************************************************************/

enum { kRead = 1, kWrite = 2, kReadWrite = 3 };

// AudioParam : a convenient class to pass parameters to the AudioInterface
struct AudioParam
{
      const char* fDeviceName;                              
      int               fSamplingFrequency;
      int               fRWMode;
      int               fSampleFormat;
      int               fFramesPerBuffer; 
      
      AudioParam() : 
            fDeviceName("/dev/dsp"),
            fSamplingFrequency(44100),
            fRWMode(kReadWrite),
            fSampleFormat(AFMT_S16_LE),
            fFramesPerBuffer(512)
      {}
      
      AudioParam& device(const char * n)  { fDeviceName = n;                  return *this; }
      AudioParam& frequency(int f)        { fSamplingFrequency = f;     return *this; }
      AudioParam& mode(int m)                   { fRWMode = m;                      return *this; }
      AudioParam& format(int f)                 { fSampleFormat = f;          return *this; }
      AudioParam& buffering(int fpb)            { fFramesPerBuffer = fpb;     return *this; }
};

class AudioInterface 
{
 private :
      AudioParam  fParam;
      int               fOutputDevice ;         
      int               fInputDevice ;                
      int               fNumOfOutputChannels;
      int               fNumOfInputChannels;
      int               fInputBufferSize;
      short*            fInputBuffer;
      int               fOutputBufferSize;
      short*            fOutputBuffer;
      

 public :
 
      const char* getDeviceName()                     { return fParam.fDeviceName;        }
      int         getSamplingFrequency()              { return fParam.fSamplingFrequency;       }
      int         getRWMode()                               { return fParam.fRWMode;            }
      int         getSampleFormat()                   { return fParam.fSampleFormat;            }
      int         getFramesPerBuffer()                { return fParam.fFramesPerBuffer;   }
      
      int         getNumOutputs()                           { return fNumOfOutputChannels;      }
      int         getNumInputs()                            { return fNumOfInputChannels;       }
      int         getInputBufferSize()                { return fInputBufferSize;          }
      int         getOutputBufferSize()               { return fOutputBufferSize;   }

      
      AudioInterface(const AudioParam& ap = AudioParam()) : fParam(ap)
      {
            fOutputDevice                 = -1;
            fInputDevice                  = -1;
            fNumOfOutputChannels    = 0;
            fNumOfInputChannels           = 0;
            fInputBufferSize        = 0;
            fInputBuffer                  = 0;
            fOutputBufferSize       = 0;
            fOutputBuffer                 = 0;
      }


      void openInputAudioDev ()
      {
            int   err = 0;

            assert( (fInputDevice = ::open(fParam.fDeviceName, O_RDONLY, 0))        > 0); 
            assert( ioctl(fInputDevice, SNDCTL_DSP_SETFMT, &fParam.fSampleFormat)         != -1);     
            assert( ioctl(fInputDevice, SNDCTL_DSP_CHANNELS, &fNumOfInputChannels) != -1);
            assert( ioctl(fInputDevice, SNDCTL_DSP_SPEED, &fParam.fSamplingFrequency)     != -1);

            int gFragFormat = (1 << 16) + int2pow2(fParam.fFramesPerBuffer * 2 * fNumOfInputChannels);      
            assert( ioctl(fInputDevice, SNDCTL_DSP_SETFRAGMENT, &gFragFormat)             != -1); 

            fInputBufferSize = 0;
            assert( ioctl(fInputDevice, SNDCTL_DSP_GETBLKSIZE, &fInputBufferSize)  != -1);
            assert( fInputBufferSize == fParam.fFramesPerBuffer * 2 * fNumOfInputChannels );

            fInputBuffer = (short*) calloc(fInputBufferSize, 1);
      }


      void openOutputAudioDev ()
      {
            int   err = 0;

            assert( (fOutputDevice = ::open(fParam.fDeviceName, O_WRONLY, 0))             >  0);      
            assert( ioctl(fOutputDevice, SNDCTL_DSP_SETFMT, &fParam.fSampleFormat)        != -1);     
            assert( ioctl(fOutputDevice, SNDCTL_DSP_CHANNELS,&fNumOfOutputChannels)!= -1);
            assert( ioctl(fOutputDevice, SNDCTL_DSP_SPEED, &fParam.fSamplingFrequency)    != -1);

            int gFragFormat = (1 << 16) + int2pow2(fParam.fFramesPerBuffer * 2 * fNumOfOutputChannels);     
            assert( ioctl(fOutputDevice, SNDCTL_DSP_SETFRAGMENT, &gFragFormat)      != -1); 

            fOutputBufferSize = 0;
            assert( ioctl(fOutputDevice, SNDCTL_DSP_GETBLKSIZE, &fOutputBufferSize) != -1);
            assert( fOutputBufferSize == fParam.fFramesPerBuffer * 2 * fNumOfOutputChannels );

            fOutputBuffer = (short*)calloc(fOutputBufferSize, 1);
      }


      void open()
      {
            if (fParam.fRWMode & kRead) openInputAudioDev();
            if (fParam.fRWMode & kWrite) openOutputAudioDev();
      }


      void close()
      {
            if (fParam.fRWMode & kRead) ::close(fOutputDevice);
            if (fParam.fRWMode & kWrite) ::close(fInputDevice);
      }


      
      //----------------------------------------------------------------
      //  allocChanGroup() : allocate a group of audio buffers
      //          chan[]      : is an array of buffer pointers
      //          n           : is the number of buffers to allocate
      //          len   : is the length of each buffer
      //----------------------------------------------------------------
      
      void allocChanGroup(float* chan[], int n, int len)
      {
            for (int c = 0; c < n; c++) {
                  chan[c] = (float*) calloc (len, sizeof(float));
            }
      }

      
      //----------------------------------------------------------------
      //  info() : print information on the audio device
      //----------------------------------------------------------------

      void info()
      {
            audio_buf_info    info;
            int                     err = 0;
            int               cap;
            printf("Audio Interface Description :\n");
            printf("Sampling Frequency : %d, Sample Format : %d, Mode : %d\n", getSamplingFrequency(), getSampleFormat(), getRWMode());
            
            if (getRWMode() & kWrite) {
                  assert( ioctl(fOutputDevice, SNDCTL_DSP_GETOSPACE, &info) != -1);
                  printf("output space info: fragments=%d, fragstotal=%d, fragsize=%d, bytes=%d\n", info.fragments, info.fragstotal,
                        info.fragsize, info.bytes);
            
                  assert( ioctl(fOutputDevice,SNDCTL_DSP_GETCAPS, &cap) != -1); 
                  printf("Output capabilities - %d channels : ", fNumOfOutputChannels);
      
                  if (cap &  DSP_CAP_DUPLEX)    printf(" DSP_CAP_DUPLEX");
                  if (cap &  DSP_CAP_REALTIME) printf(" DSP_CAP_REALTIME");
                  if (cap &  DSP_CAP_DUPLEX)    printf(" DSP_CAP_DUPLEX");
                  if (cap &  DSP_CAP_BATCH)     printf(" DSP_CAP_BATCH");
                  if (cap &  DSP_CAP_COPROC)    printf(" DSP_CAP_COPROC");
                  if (cap &  DSP_CAP_TRIGGER) printf(" DSP_CAP_TRIGGER");
                  if (cap &  DSP_CAP_MMAP)      printf(" DSP_CAP_MMAP");
                  if (cap &  DSP_CAP_MULTI)     printf(" DSP_CAP_MULTI");
                  if (cap &  DSP_CAP_BIND)      printf(" DSP_CAP_BIND");
                  printf("\n");
                  printf("Output block size = %d\n", fOutputBufferSize);
            }     

            
            if (getRWMode() & kRead) {
                  assert( ioctl(fInputDevice, SNDCTL_DSP_GETISPACE, &info) != -1);
                  printf("input space info: fragments=%d, fragstotal=%d, fragsize=%d, bytes=%d\n", info.fragments, info.fragstotal,
                        info.fragsize, info.bytes);


                  assert( ioctl(fInputDevice,SNDCTL_DSP_GETCAPS, &cap) != -1); 
                  printf("Input capabilities - %d channels : ", fNumOfInputChannels);
                  if (cap &  DSP_CAP_DUPLEX)    printf(" DSP_CAP_DUPLEX");
                  if (cap &  DSP_CAP_REALTIME) printf(" DSP_CAP_REALTIME");
                  if (cap &  DSP_CAP_DUPLEX)    printf(" DSP_CAP_DUPLEX");
                  if (cap &  DSP_CAP_BATCH)     printf(" DSP_CAP_BATCH");
                  if (cap &  DSP_CAP_COPROC)    printf(" DSP_CAP_COPROC");
                  if (cap &  DSP_CAP_TRIGGER) printf(" DSP_CAP_TRIGGER");
                  if (cap &  DSP_CAP_MMAP)      printf(" DSP_CAP_MMAP");
                  if (cap &  DSP_CAP_MULTI)     printf(" DSP_CAP_MULTI");
                  if (cap &  DSP_CAP_BIND)      printf(" DSP_CAP_BIND");
                  printf("\n");
                  printf("Input block size = %d\n", fInputBufferSize);
            }
      }


      //----------------------------------------------------------------
      //  read() : read 
      //----------------------------------------------------------------

      bool read(int frames, float* channel[])
      {
            int   bytes = frames * 2 * fNumOfInputChannels; assert(bytes <= fInputBufferSize);
            int         count = ::read(fInputDevice, fInputBuffer, bytes);
            assert (bytes == count);

            for (int s = 0; s < frames; s++) {
                  for (int c = 0; c < fNumOfInputChannels; c++) {
                        channel[c][s] = float(fInputBuffer[c + s*fNumOfInputChannels])*(1.0/float(SHRT_MAX));
                  }
            }
            return bytes == count;
      }     


      bool write(int frames, float* channel[])
      {
            int   bytes = frames * 2 * fNumOfOutputChannels; assert(bytes <= fOutputBufferSize);

            for (int f = 0; f < frames; f++) {
                  for (int c = 0; c < fNumOfOutputChannels; c++) {
                        float x = channel[c][f];
                        fOutputBuffer[c + f*fNumOfOutputChannels] = short( max(min(x,1.0),-1.0) * float(SHRT_MAX) ) ;
                  }
            }

            int count = ::write(fOutputDevice, fOutputBuffer, bytes);
            assert (bytes == count);

            return bytes == count;
      } 


      
};






/******************************************************************************
*******************************************************************************

                                                USER INTERFACE

*******************************************************************************
*******************************************************************************/

class UI
{
      bool  fStopped;
public:
            
      UI() : fStopped(false) {}
      virtual ~UI() {}
      
      virtual void addButton(char* label, float* zone) = 0;
      virtual void addToggleButton(char* label, float* zone) = 0;
      virtual void addCheckButton(char* label, float* zone) = 0;
      virtual void addVerticalSlider(char* label, float* zone, float init, float min, float max, float step) = 0;
      virtual void addHorizontalSlider(char* label, float* zone, float init, float min, float max, float step) = 0;
      virtual void addNumEntry(char* label, float* zone, float init, float min, float max, float step) = 0;
      
      virtual void openFrameBox(char* label) = 0;
      virtual void openTabBox(char* label) = 0;
      virtual void openHorizontalBox(char* label) = 0;
      virtual void openVerticalBox(char* label) = 0;
      virtual void closeBox() = 0;
      
      virtual void run() {};
      
      void stop()       { fStopped = true; }
      bool stopped()    { return fStopped; }
};



/******************************************************************************
*******************************************************************************

                                                DSP

*******************************************************************************
*******************************************************************************/


//---------------------------------------------------
// tableaux de buffers initialis�s par allocChannels
//---------------------------------------------------

float*      gInChannel[256];
float*      gOutChannel[256];

void allocChannels (int size, int numInChan, int numOutChan) 
{
      
      assert (numInChan < 256);
      assert (numOutChan < 256);
      
      
      for (int i = 0; i < numInChan; i++) {
            gInChannel[i] = (float*) calloc (size, sizeof(float));
            for (int j = 0; j < size; j++) {
                  gInChannel[i][j] = 0.0;
            }
      }
      
      for (int i = 0; i < numOutChan; i++) {
            gOutChannel[i] = (float*) calloc (size, sizeof(float));
            for (int j = 0; j < size; j++) {
                  gOutChannel[i][j] = 0.0;
            }
      }
}



//----------------------------------------------------------------
//  d�finition du processeur de signal
//----------------------------------------------------------------
                  
class dsp {
 protected:
      int fSamplingFreq;
 public:
      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;
};
            
            
<<includeclass>>
            
                        
mydsp DSP;


/******************************************************************************
*******************************************************************************

                                          WXWINDOWS USER INTERFACE

*******************************************************************************
*******************************************************************************/


// les modes d'insertion

#define kNormalState 0
#define kNotebookState 1
#define kAutoPageState 2

#define kProp 0
#define kBorder 5
#define kFlag wxALL|wxGROW

      
// faustButton : a wxButton for FAUST. 
class faustButton : public wxButton
{
      float*      fZone;
  public :
      faustButton(wxWindow* parent, const wxString& label, float* zone)
                  : wxButton(parent, -1, label, wxPoint(-1, -1)), fZone(zone)
      { 
            *fZone = 0.0;
      }
  
      void clickdown (wxCommandEvent& ev) { *fZone = 1.0; /*printf("click down : zone (at %p) = %f\n", fZone, *fZone);*/ ev.Skip();}
      void clickup (wxCommandEvent& ev)   { *fZone = 0.0; /*printf("click up : zone (at %p) = %f\n", fZone, *fZone);*/ ev.Skip(); }
      
 private:
      DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(faustButton, wxButton)
   EVT_LEFT_DOWN(faustButton::clickdown)
   EVT_LEFT_UP(faustButton::clickup)
END_EVENT_TABLE()
            
      
class faustCheckBox : public wxCheckBox
{
      float*      fZone;
  public :
      faustCheckBox(wxWindow* parent, const wxString& label, float* zone)
                  : wxCheckBox(parent, -1, label, wxPoint(-1, -1)), fZone(zone)
      { 
            *fZone = 0.0;
      }
  
      void toggle (wxCommandEvent& ev)    { 
            *fZone = (ev.IsChecked()) ? 1.0 : 0.0; 
            //printf("toogle : zone (at %p) = %f\n", fZone, *fZone); 
      }
      
 private:
      DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(faustCheckBox, wxCheckBox)
    EVT_CHECKBOX(-1, faustCheckBox::toggle)
END_EVENT_TABLE()
            
      
class faustHorizontalSlider : public wxSlider
{
      float fStep;
      float*      fZone;
  public :
      faustHorizontalSlider(wxWindow* parent, float* zone, float init , float min, float max, float step)
                  : wxSlider(parent, -1, int(init/step), int(min/step), int(max/step), wxDefaultPosition, wxSize(120,30), wxSL_HORIZONTAL), fStep(step), fZone(zone)
      { 
            *fZone = init;
      }
  
      void update (wxCommandEvent& ev)    { 
            *fZone = GetValue()*fStep; 
            //printf("horizontal slider update : zone (at %p) = %f\n", fZone, *fZone); 
      }
      
 private:
      DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(faustHorizontalSlider, wxSlider)
      EVT_SLIDER (-1, faustHorizontalSlider::update)
END_EVENT_TABLE()
            
      
class faustVerticalSlider : public wxSlider
{
      float fStep;
      float*      fZone;
  public :
      faustVerticalSlider(wxWindow* parent, float* zone, float init , float min, float max, float step)
                  : wxSlider(parent, -1, int((max+min-init)/step), int(min/step), int(max/step), wxDefaultPosition, wxSize(30,120), wxSL_VERTICAL), fStep(step), fZone(zone)
      { 
            *fZone = init;
      }
  
      void update (wxCommandEvent& ev)    { 
            *fZone = (GetMin()+GetMax()-GetValue())*fStep; 
            //printf("vertical slider update : zone (at %p) = %f\n", fZone, *fZone); 
      }
      
 private:
      DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(faustVerticalSlider, wxSlider)
      EVT_SLIDER (-1, faustVerticalSlider::update)
END_EVENT_TABLE()

            
//--------------------------------
// faustSpinCtrl* b = new faustSpinCtrl(topPanel(), zone, init, min, max, step);
//                wxSpinCtrl* b = new wxSpinCtrl( topPanel(), -1, "", wxPoint(200, 160), wxSize(80, -1) );
//                b->SetRange(int(min),int(max));
//                b->SetValue(int(init));       
            
      
class faustSpinCtrl : public wxSpinCtrl
{
      float fStep;
      float*      fZone;
  public :
      faustSpinCtrl(wxWindow* parent, float* zone, float init , float min, float max, float step)
                  : wxSpinCtrl(parent), fStep(step), fZone(zone)
      { 
            SetRange(int(min),int(max));
            SetValue(int(init));
            *fZone = init;
      }
      
      void update (wxCommandEvent& ev)    { *fZone = GetValue(); printf("spin ctrl update : zone (at %p) = %f\n", fZone, *fZone); }
      
 private:
      DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(faustSpinCtrl, wxSlider)
      EVT_SPINCTRL (-1, faustSpinCtrl::update)
END_EVENT_TABLE()

            
            
class WXUI : public UI // user interface
{

      class State 
      {
            int               const fType;
            wxWindow*   const fPanel;
            wxSizer*    const fSizer;

       public:
            State (int t, wxWindow* p, wxSizer* z) : fType(t), fPanel(p), fSizer(z) {}
            int               type()      const { return fType; }
            wxWindow*   panel() const { return fPanel; }
            wxSizer*    sizer() const { return fSizer; }
      };
      
      stack<State>            lState;
      wxFrame*                frame;
      wxSizer*                fSizer;
      
      // gestion de l'etat courant du constructeur
      
      void push (int t, wxWindow* p, wxSizer* z)      
      { 
            printf("push %d of %d, %p, %p\n", lState.size(), t, p, z);
            lState.push(State(t,p,z)); 
      }
      
      int               topType()   { return lState.top().type();       }
      wxWindow*   topPanel()  { return lState.top().panel();      }
      wxSizer*    topSizer()  { return lState.top().sizer();      }
      
      void pop ()                                                 
      { 
            printf("pop %d", lState.size()-1);
            lState.pop();                 
            printf(" ok\n");
      }
              
      void openAutoPage(char* label)
      {
            if (topType() == kNotebookState) {  
                              
                  if (!label) label = "";
            
            wxNotebook* nb    = (wxNotebook*) topPanel();
            wxPanel*    p     = new wxPanel( nb, -1 );
            wxBoxSizer* z     = new wxBoxSizer( wxVERTICAL );
                  
            nb->AddPage(p, label);
            p->SetAutoLayout(TRUE);
            p->SetSizer(z);
                  
                  push(kAutoPageState, p, z);
            }
      }
      
      void closeAutoPage()
      {
            if (topType() == kAutoPageState) pop(); 
      }
      
      void openOrientedBox(char* label, int orientation) 
      {
            openAutoPage(label);
            
            wxSizer* z = (label == 0)     ? new wxBoxSizer(orientation) 
                                                      : new wxStaticBoxSizer(new wxStaticBox(topPanel(), -1, label), orientation);
            
            topSizer()->Add(z, 1, kFlag, kBorder);
            push(kNormalState, topPanel(), z);
      }
      
 public:
      

      WXUI(){}
      
      virtual ~WXUI() {}
      
      void openFrame(wxFrame* f) 
      {
            frame = f;
            fSizer = new wxBoxSizer(wxVERTICAL);
            frame->SetSizer(fSizer);
            push(kNormalState, frame, fSizer);
      }
            
      wxFrame* closeFrame()
      {
            fSizer->Fit(frame);
            fSizer->SetSizeHints(frame);
            return frame;
      }
      
      virtual void openHorizontalBox(char* label) {   openOrientedBox(label, wxHORIZONTAL); }
      virtual void openVerticalBox(char* label)       {     openOrientedBox(label, wxVERTICAL); }
      
      virtual void openTabBox(char* label) 
      {
            openAutoPage(label);
            
      wxNotebook*             nb    = new wxNotebook( topPanel(), -1 );
      wxNotebookSizer*  z     = new wxNotebookSizer( nb );
            
            topSizer()->Add(z, 1, kFlag, kBorder);          
            push(kNotebookState, nb, z);
      }
      
      virtual void closeBox()
      {
            pop();
            closeAutoPage();
      }
                        
      //--------------------------------- les elements ------------------------------------------
            
      virtual void addButton(char* label, float* zone) 
      {
            openAutoPage(label);
            faustButton* b = new faustButton(topPanel(), label, zone);
            topSizer()->Add(b, kProp, kFlag, kBorder);
            closeAutoPage();
      }
      
      virtual void addCheckButton(char* label, float* zone)  
      {
            openAutoPage(label);
            faustCheckBox* b = new faustCheckBox(topPanel(), label, zone);
            topSizer()->Add(b, kProp, kFlag, kBorder);
            closeAutoPage();
      }
                  
      virtual void addVerticalSlider(char* label, float* zone, float init, float min, float max, float step) 
      {
            openAutoPage(label);
            if (label) {
                  wxSizer* z = new wxStaticBoxSizer(new wxStaticBox(topPanel(), -1, label), wxHORIZONTAL);
                  topSizer()->Add(z, 1, kFlag, kBorder);
                  faustVerticalSlider* b = new faustVerticalSlider(topPanel(), zone, init, min, max, step);
                  b->SetToolTip(label);
                  z->Add(b, 1, kFlag|wxALIGN_CENTER_VERTICAL, kBorder);
            } else {
                  faustVerticalSlider* b = new faustVerticalSlider(topPanel(), zone, init, min, max, step);
                  topSizer()->Add(b, kProp, kFlag, kBorder);
            }
            closeAutoPage();
      }
      
      virtual void addHorizontalSlider(char* label, float* zone, float init, float min, float max, float step) 
      {
            openAutoPage(label);
            if (label) {
                  wxSizer* z = new wxStaticBoxSizer(new wxStaticBox(topPanel(), -1, label), wxVERTICAL);
                  topSizer()->Add(z, 1, kFlag, kBorder);
                  faustHorizontalSlider* b = new faustHorizontalSlider(topPanel(), zone, init, min, max, step);
                  b->SetToolTip(label);
                  z->Add(b, 1, kFlag|wxALIGN_CENTER_HORIZONTAL, kBorder);
            } else {
                  faustHorizontalSlider* b = new faustHorizontalSlider(topPanel(), zone, init, min, max, step);
                  topSizer()->Add(b, kProp, kFlag, kBorder);
            }
            closeAutoPage();
      }
      
      virtual void addToggleButton(char* label, float* zone) {}   
      virtual void addNumEntry(char* label, float* zone, float init, float min, float max, float step) 
      {
            openAutoPage(label);
            if (label) {
                  wxSizer* z = new wxStaticBoxSizer(new wxStaticBox(topPanel(), -1, label), wxVERTICAL);
                  topSizer()->Add(z, 0, kFlag, kBorder);
                  faustSpinCtrl* b = new faustSpinCtrl(topPanel(), zone, init, min, max, step);
//                wxSpinCtrl* b = new wxSpinCtrl( topPanel(), -1, "", wxPoint(200, 160), wxSize(80, -1) );
//                b->SetRange(int(min),int(max));
//                b->SetValue(int(init));
                  b->SetToolTip(label);
                  z->Add(b, 0, kFlag, kBorder);
            } else {
                  faustSpinCtrl* b = new faustSpinCtrl(topPanel(), zone, init, min, max, step);
//                wxSpinCtrl* b = new wxSpinCtrl( topPanel(), -1, "", wxPoint(200, 160), wxSize(80, -1) );
//                b->SetRange(int(min),int(max));
//                b->SetValue(int(init));
                  topSizer()->Add(b, kProp, kFlag, kBorder);
            }
            closeAutoPage();
      }
      virtual void openFrameBox(char* label) {}
};



/******************************************************************************
*******************************************************************************

                                          WXWINDOWS APPLICATION
                                                
*******************************************************************************
*******************************************************************************/


enum { ID_QUIT=1, ID_ABOUT };
 
 
class MyApp : public wxApp
{
      virtual bool OnInit();
};


class MyFrame : public wxFrame
{
 public:
      MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size) 
      : wxFrame(0, -1, title, pos, size)
      {
            wxMenu* m = new wxMenu;
            m->Append(ID_ABOUT, "&About...");
            m->AppendSeparator();
            m->Append(ID_QUIT, "E&xit");
            
            wxMenuBar* b = new wxMenuBar;
            b->Append(m, "&File");
            SetMenuBar(b);
            CreateStatusBar();
            SetStatusText("hello...");
      }
      
      void OnQuit(wxCommandEvent& event)
      {
            Close(TRUE);
      }
      
      void OnAbout(wxCommandEvent& event)
      {
            wxMessageBox("message 1", "message 2", wxOK|wxICON_INFORMATION);
      }

 private:
      DECLARE_EVENT_TABLE()
};
 
 
 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
             EVT_MENU(ID_QUIT, MyFrame::OnQuit)
             EVT_MENU(ID_ABOUT, MyFrame::OnAbout)
 END_EVENT_TABLE()

             

IMPLEMENT_APP(MyApp)


/******************************************************************************
*******************************************************************************

                                                MAIN PLAY THREAD

*******************************************************************************
*******************************************************************************/
      
// Scan Command Line Arguments

long lopt (char *argv[], char *name, long def) 
{
      int   i;
      for (i=0; argv[i]; i++) if (!strcmp(argv[i], name)) return atoi(argv[i+1]);
      return def;
}
      

//-------------------------------------------------------------------------
//                                                    MAIN
//-------------------------------------------------------------------------
float*            inChannel[256];
float*            outChannel[256];
int               fpb;

pthread_t   soundthread;
      
void* run_sound(void* ptr)
{
      AudioInterface*   audio = (AudioInterface*)ptr;
      
      setRealtimePriority();
      // Sound processing loop
      audio->write(fpb, outChannel);      
      audio->write(fpb, outChannel);      
      while (1) {
            if ( !audio->write(fpb, outChannel)) printf("w");     
            if ( !audio->read (fpb, inChannel)) printf("r");;     
            DSP.compute(fpb, inChannel, outChannel);
      }
      
      audio->close();
      return 0;
}

bool MyApp::OnInit()
{
      // create and init the audio interface card
      AudioInterface*   audio = new AudioInterface(
            AudioParam().frequency(lopt(argv, "--frequency", 44100)) 
                              .buffering(lopt(argv, "--buffer", 128))
                              //.mode( ((DSP.getNumInputs()>0)?kRead:0) | ((DSP.getNumOutputs()>0)?kWrite:0) )
      );
      audio->open();
      audio->info();
      
      
      
      MyFrame* frame = new MyFrame(argv[0], wxPoint(50,50), wxSize(-1, -1));

      wxMenu* m = new wxMenu;
      m->Append(ID_ABOUT, "&About...");
      m->AppendSeparator();
      m->Append(ID_QUIT, "E&xit");
            
      wxMenuBar* b = new wxMenuBar;
      b->Append(m, "&File");
            
      frame->SetMenuBar(b);
      frame->CreateStatusBar();
      frame->SetStatusText("hello...");
                        
      WXUI* ui = new WXUI();
      ui->openFrame(frame);
      DSP.buildUserInterface((UI*)ui);
      ui->closeFrame();
      
      DSP.init(audio->getSamplingFrequency());
      fpb = audio->getFramesPerBuffer();  
      audio->allocChanGroup(inChannel,  max(audio->getNumInputs(),  DSP.getNumInputs()), fpb);
      audio->allocChanGroup(outChannel, max(audio->getNumOutputs(), DSP.getNumOutputs()), fpb);
      
      frame->Show(TRUE);
      SetTopWindow(frame);
      
      pthread_create(&soundthread, NULL, run_sound, audio);

      return TRUE;
}

Generated by  Doxygen 1.6.0   Back to index