*** empty log message ***

svn path=/trunk/externals/tb/; revision=1012

6 files changed, 897 insertions, 0 deletions

diff --git a/tbext/source/fftbuf.cpp b/tbext/source/fftbuf.cpp
new file mode 100644
index 0000000..eff81e3
--- /dev/null
+++ b/tbext/source/fftbuf.cpp
@@ -0,0 +1,247 @@
+/* Copyright (c) 2003 Tim Blechmann.                                            */
+/* For information on usage and redistribution, and for a DISCLAIMER OF ALL     */
+/* WARRANTIES, see the file, "COPYING"  in this distribution.                   */
+/*                                                                              */
+/*                                                                              */
+/* fftbuf~ fades between two buffers. it is intended to be used as fft          */
+/* synthesis tool...                                                            */
+/*                                                                              */
+/*                                                                              */
+/* fftbuf~ uses the flext C++ layer for Max/MSP and PD externals.               */
+/* get it at http://www.parasitaere-kapazitaeten.de/PD/ext                      */
+/* thanks to Thomas Grill                                                       */
+/*                                                                              */
+/*                                                                              */
+/*                                                                              */
+/* 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.                       */
+/*                                                                              */
+/* See file LICENSE for further informations on licensing terms.                */
+/*                                                                              */
+/* 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.  */
+/*                                                                              */
+/* Based on PureData by Miller Puckette and others.                             */
+/*                                                                              */
+/*                                                                              */
+/*                                                                              */
+/* coded while listening to: Jérôme Noetinger/ErikM: What a Wonderful World     */
+/*                           Cosmos: Tears                                      */
+/*                           Burkhard Stangl/Dieb13: eh                         */
+/*                                                                              */
+
+
+
+#include <flext.h>
+
+#if !defined(FLEXT_VERSION) || (FLEXT_VERSION < 401)
+#error upgrade your flext version!!!!!!
+#endif
+
+
+class fftbuf: public flext_dsp
+{
+  FLEXT_HEADER(fftbuf,flext_dsp);
+
+public: // constructor
+  
+  fftbuf(int);
+  ~fftbuf();
+
+protected:
+  virtual void m_signal (int n, float *const *in, float *const *out);
+  bool check(buffer *);
+
+  
+  void set_buf(int argc,  t_atom *argv); //selects a new buffer
+  void set_line(int argc,  t_atom *argv); //sets the time for the transformance
+  
+  template<typename T>
+  void clear(T *); //destroys an object
+  
+  void perform(); //starts transformation
+  
+  int blknumber(); //number of blocks that a performance needs
+
+private:
+  FLEXT_CALLBACK_V(set_buf);
+  FLEXT_CALLBACK_V(set_line);
+  FLEXT_CALLBACK(perform);
+
+  float *ins;
+  float *outs;
+
+  t_symbol * bufname; 
+  buffer * buf;
+    
+  int delay; //delay for fading from local buffer to new one
+  t_sample * data; // pointer to array of samples
+  t_sample * offset; // pointer to array of samples
+
+  int bs; //blocksize+1
+  int sr; //samplerate
+  int counter;
+};
+
+
+FLEXT_LIB_DSP_1("bufline~",fftbuf,int);
+
+fftbuf::fftbuf(int arg):
+  buf(NULL),data(NULL),sr(Samplerate()),delay(0),counter(0)
+{
+  bs=arg+1;
+  AddInAnything();
+  AddOutSignal();
+  FLEXT_ADDMETHOD_(0,"set",set_buf);
+  FLEXT_ADDMETHOD_(0,"line",set_line);
+  FLEXT_ADDBANG(0,perform);
+
+  
+  data= new t_sample[bs];
+  offset= new t_sample[bs];
+  ZeroSamples(data,bs);
+  ZeroSamples(offset,bs);
+}
+
+
+fftbuf::~fftbuf()
+{
+  delete data;
+  delete offset;
+}
+
+
+void fftbuf::m_signal(int n, t_float *const *in, t_float *const *out)
+{
+  outs = out[0];
+  
+  if (counter!=0)
+    {
+      n=n/2+1;
+      while (--n)
+	data[n] = data[n] - offset[n];
+      
+      
+      /*      for(int i=0;i!=bs;++i)
+      {
+	data[i] = data[i] - offset[i];
+      }
+      */
+
+      --counter;
+    }
+
+  CopySamples(out[0],data,bs);
+}
+
+void fftbuf::perform()
+{
+  counter=blknumber();
+  if (counter)
+    {
+      for(int i=0;i!=bs;++i)
+	{
+	  offset[i]=(data[i]-*(buf->Data()+i))/counter; 
+	}
+      
+    }
+  else
+    {
+      CopySamples(data,buf->Data(),bs);
+    }
+}
+
+void fftbuf::set_buf(int argc, t_atom *argv)
+{
+  if(argc == 0)
+    {
+      post("No buffer selected!!!");
+      return;
+    }
+  if (argc == 1 && IsSymbol(argv[0]))
+    {
+      clear(buf);
+      bufname=GetSymbol(argv[0]);
+      
+      buf= new buffer(bufname);
+      
+      if(!buf->Ok())
+	{
+	  post("buffer %s is currently not valid",bufname);
+	}
+    }
+  else if ((argc == 2 && IsSymbol(argv[0]) && 
+	    (IsInt(argv[1]) || IsFloat(argv[1]))))
+    {
+      clear(buf);
+      bufname=GetSymbol(argv[0]);
+      
+      buf= new buffer(bufname);
+      
+      if(!buf->Ok())
+	{
+	  post("buffer %s is currently not valid",bufname);
+	  return;
+	}
+      delay=GetInt(argv[1]);
+    }
+}
+
+template<typename T>
+/*inline*/ void fftbuf::clear(T* buf)
+{
+  if (buf)
+    {
+      delete buf;
+      buf=NULL;
+    }
+}
+
+inline bool fftbuf::check(buffer * buf) 
+{
+//code taken from the flext tutorial (buffer 1) by thomas grill
+
+  if(buf->Update()) 
+    {
+      // buffer parameters have been updated
+      if(buf->Valid()) 
+	{
+	  post("%s (%s) - updated buffer reference",
+	       thisName(),GetString(thisTag()));
+	  return true;
+	}
+      else 
+	{
+	  post("%s (%s) - buffer has become invalid",
+	       thisName(),GetString(thisTag()));
+	  return false;
+	}
+      }
+  else
+    return true;		
+}
+
+void fftbuf::set_line(int argc, t_atom *argv)
+{
+  if(argc==1 && (IsInt(argv[0]) || IsFloat(argv[0])))
+    {
+      delay=GetInt(argv[0]);
+    }
+  else
+    post("syntax incorrect");
+}
+
+inline int fftbuf::blknumber()
+{
+  //  post("%i %i %i",delay,bs,sr);
+  //  post("computer counter: %i",delay*bs/sr*1000);
+  return delay*bs/sr*1000; //ms/sample
+}
diff --git a/tbext/source/fftgrrev.cpp b/tbext/source/fftgrrev.cpp
new file mode 100644
index 0000000..e26135c
--- /dev/null
+++ b/tbext/source/fftgrrev.cpp
@@ -0,0 +1,165 @@
+/* Copyright (c) 2003 Tim Blechmann.                                            */
+/* For information on usage and redistribution, and for a DISCLAIMER OF ALL     */
+/* WARRANTIES, see the file, "COPYING"  in this distribution.                   */
+/*                                                                              */
+/*                                                                              */
+/* fftgrshuf divides the incoming fft signal into single grains and reverses    */
+/* the samples in every grain                                                   */
+/*                                                                              */
+/* fftgrrev uses the flext C++ layer for Max/MSP and PD externals.              */
+/* get it at http://www.parasitaere-kapazitaeten.de/PD/ext                      */
+/* thanks to Thomas Grill                                                       */
+/*                                                                              */
+/*                                                                              */
+/*                                                                              */
+/* 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.                       */
+/*                                                                              */
+/* See file LICENSE for further informations on licensing terms.                */
+/*                                                                              */
+/* 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.  */
+/*                                                                              */
+/* Based on PureData by Miller Puckette and others.                             */
+/*                                                                              */
+/*                                                                              */
+/*                                                                              */
+/* coded while listening to: Howard Skempton/John Tilbury: Well, well, Cornelius*/
+/*                                                                              */
+/*                                                                              */
+
+
+
+#include <flext.h>
+#include <algorithm>
+
+#if !defined(FLEXT_VERSION) || (FLEXT_VERSION < 401)
+#error upgrade your flext version!!!!!!
+#endif
+
+class fftgrrev: public flext_dsp
+{
+  FLEXT_HEADER(fftgrrev,flext_dsp);
+
+public: // constructor
+  fftgrrev(int);
+
+protected:
+  virtual void m_signal (int n, float *const *in, float *const *out);
+  void set_grains(t_int);
+  void set_offset(t_int);
+  void set_reverse();
+  
+private:
+  FLEXT_CALLBACK_1(set_grains,t_int)
+  FLEXT_CALLBACK_1(set_offset,t_int)
+    
+  t_int grains;
+  t_int grainsize;
+  t_int offset;
+  
+  t_int bs; //blocksize
+  t_int bs1; //bs+1
+  t_int counter;
+
+  t_sample * data; //array with data
+  t_sample * d1; //1. element in array with data
+  t_sample * dend; //1 element after the last element
+  
+  t_sample * ins;
+  t_sample * outs;
+
+  bool reverse;
+  
+};
+
+
+FLEXT_LIB_DSP_1("fftgrrev~",fftgrrev,int)
+
+fftgrrev::fftgrrev(int arg):
+  grains(1),offset(0),counter(1)
+{
+  bs=arg/2;
+  grainsize=bs;
+  bs1=bs+1;
+  post("blocksize: %i",bs);
+  
+  data = new t_sample[bs+1];
+  
+  data[0]=0;
+  d1=data+1;
+  dend=data+bs+1;
+  
+  AddInSignal();
+  AddOutSignal();
+  FLEXT_ADDMETHOD_I(0,"grains",set_grains);
+  FLEXT_ADDMETHOD_I(0,"offset",set_offset);
+} 
+
+void fftgrrev::m_signal(int n, t_float * const *in, t_float *const *out)
+{
+  ins = in[0];
+  outs = out[0];
+
+
+  if (offset>0)
+    {
+      CopySamples(d1+bs-offset,ins,offset);
+      CopySamples(d1,ins+offset,bs-offset);
+    }
+  else if (offset<0)
+    {
+      CopySamples(d1-offset,ins,bs+offset);
+      CopySamples(d1,ins+bs+offset,-offset);
+    } 
+  else 
+    CopySamples(data,ins,bs1);
+  
+  
+  //grains
+  
+  counter=1;
+  
+  while (counter!=grains)
+    {
+      std::reverse(d1+grainsize*(counter-1),d1+grainsize*counter);
+      ++counter;
+    }
+  
+  std::reverse(d1+grainsize*(counter-1),dend);
+  
+  CopySamples(outs,data,bs1);
+}
+
+void fftgrrev::set_offset(t_int o)
+{
+  if (o-bs<0 && o+bs>0)
+    {
+      offset=-o;
+      post("offset %i",o);
+    }
+  else
+    post("Offset out of range!");
+}
+
+
+void fftgrrev::set_grains(t_int g)
+{
+  if (  (g > 0) )
+    {
+      grains=g;
+      grainsize=(bs)/grains;
+    }
+}
+
+
+
+
diff --git a/tbext/source/fftgrshuf.cpp b/tbext/source/fftgrshuf.cpp
new file mode 100644
index 0000000..b490dcf
--- /dev/null
+++ b/tbext/source/fftgrshuf.cpp
@@ -0,0 +1,161 @@
+/* Copyright (c) 2003 Tim Blechmann.                                            */
+/* For information on usage and redistribution, and for a DISCLAIMER OF ALL     */
+/* WARRANTIES, see the file, "COPYING"  in this distribution.                   */
+/*                                                                              */
+/*                                                                              */
+/* fftgrshuf divides the incoming fft signal into single grains and             */
+/* random_shuffles the samples in every grain                                   */
+/*                                                                              */
+/* fftgrshuf uses the flext C++ layer for Max/MSP and PD externals.             */
+/* get it at http://www.parasitaere-kapazitaeten.de/PD/ext                      */
+/* thanks to Thomas Grill                                                       */
+/*                                                                              */
+/*                                                                              */
+/*                                                                              */
+/* 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.                       */
+/*                                                                              */
+/* See file LICENSE for further informations on licensing terms.                */
+/*                                                                              */
+/* 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.  */
+/*                                                                              */
+/* Based on PureData by Miller Puckette and others.                             */
+/*                                                                              */
+/*                                                                              */
+/*                                                                              */
+/* coded while listening to: New York Underground Orchestra: The Labyrinth      */
+/*                                                                              */
+/*                                                                              */
+
+
+
+#include <flext.h>
+#include <algorithm>
+
+#if !defined(FLEXT_VERSION) || (FLEXT_VERSION < 401)
+#error upgrade your flext version!!!!!!
+#endif
+
+class fftgrshuf: public flext_dsp
+{
+  FLEXT_HEADER(fftgrshuf,flext_dsp);
+
+public: // constructor
+  fftgrshuf(int);
+
+protected:
+  virtual void m_signal (int n, float *const *in, float *const *out);
+  void set_grains(t_int);
+  void set_offset(t_int);
+  
+private:
+  FLEXT_CALLBACK_1(set_grains,t_int)
+  FLEXT_CALLBACK_1(set_offset,t_int)
+    
+  t_int grains;
+  t_int grainsize;
+  t_int offset;
+  
+  t_int bs; //blocksize
+  t_int bs1; //bs+1
+  t_int counter;
+
+  t_sample * data; //array with data
+  t_sample * d1; //1. element in array with data
+  t_sample * dend; //1 element after the last element
+  
+  t_sample * ins;
+  t_sample * outs;
+
+  
+};
+
+
+FLEXT_LIB_DSP_1("fftgrshuf~",fftgrshuf,int)
+
+fftgrshuf::fftgrshuf(int arg):
+  grains(1),offset(0),counter(1)
+{
+  bs=arg/2;
+  grainsize=bs;
+  bs1=bs+1;
+  post("blocksize: %i",bs);
+  
+  data = new t_sample[bs+1];
+  
+  data[0]=0;
+  d1=data+1;
+  dend=data+bs+1;
+  
+  AddInSignal();
+  AddOutSignal();
+  FLEXT_ADDMETHOD_I(0,"grains",set_grains);
+  FLEXT_ADDMETHOD_I(0,"offset",set_offset);
+} 
+
+void fftgrshuf::m_signal(int n, t_float * const *in, t_float *const *out)
+{
+  ins = in[0];
+  outs = out[0];
+
+
+  if (offset>0)
+    {
+      CopySamples(d1+bs-offset,ins,offset);
+      CopySamples(d1,ins+offset,bs-offset);
+    }
+  else if (offset<0)
+    {
+      CopySamples(d1-offset,ins,bs+offset);
+      CopySamples(d1,ins+bs+offset,-offset);
+    } 
+  else 
+    CopySamples(data,ins,bs1);
+  
+  
+  //grains
+  
+  counter=1;
+  
+  while (counter!=grains) 
+    {
+      std::random_shuffle(d1+grainsize*(counter-1),d1+grainsize*counter);
+      ++counter;
+    }
+  
+  std::random_shuffle(d1+grainsize*(counter-1),dend);
+
+  
+  CopySamples(outs,data,bs1);
+}
+
+void fftgrshuf::set_offset(t_int o)
+{
+  if (o-bs<0 && o+bs>0)
+    {
+      offset=o;
+      post("offset %i",-o);
+    }
+  else
+    post("offset out of range!");
+}
+
+
+void fftgrshuf::set_grains(t_int g)
+{
+  if (  (g > 0) )
+    {
+      grains=g;
+      grainsize=(bs)/grains;
+    }
+}
+
diff --git a/tbext/source/fftgrsort.cpp b/tbext/source/fftgrsort.cpp
new file mode 100644
index 0000000..f24ed0f
--- /dev/null
+++ b/tbext/source/fftgrsort.cpp
@@ -0,0 +1,176 @@
+/* Copyright (c) 2003 Tim Blechmann.                                            */
+/* For information on usage and redistribution, and for a DISCLAIMER OF ALL     */
+/* WARRANTIES, see the file, "COPYING"  in this distribution.                   */
+/*                                                                              */
+/*                                                                              */
+/* fftgrsort divides the incoming fft signal into single grains and sorts the   */
+/* samples in every grain                                                       */
+/*                                                                              */
+/* fftgrsort uses the flext C++ layer for Max/MSP and PD externals.             */
+/* get it at http://www.parasitaere-kapazitaeten.de/PD/ext                      */
+/* thanks to Thomas Grill                                                       */
+/*                                                                              */
+/*                                                                              */
+/*                                                                              */
+/* 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.                       */
+/*                                                                              */
+/* See file LICENSE for further informations on licensing terms.                */
+/*                                                                              */
+/* 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.  */
+/*                                                                              */
+/* Based on PureData by Miller Puckette and others.                             */
+/*                                                                              */
+/*                                                                              */
+/*                                                                              */
+/* coded while listening to:  William Parker: Posium Pendasem                   */
+/*                            Rowe/Lehn/Schmickler: Rabbit Run                  */
+/*                            Derek Bailey: Ballads                             */
+/*                                                                              */
+
+
+
+#include <flext.h>
+#include <algorithm>
+
+#if !defined(FLEXT_VERSION) || (FLEXT_VERSION < 401)
+#error upgrade your flext version!!!!!!
+#endif
+
+class fftgrsort: public flext_dsp
+{
+  FLEXT_HEADER(fftgrsort,flext_dsp);
+
+public: // constructor
+  fftgrsort(int);
+
+protected:
+  virtual void m_signal (int n, float *const *in, float *const *out);
+  void set_grains(t_int);
+  void set_offset(t_int);
+  void set_reverse();
+  
+private:
+  FLEXT_CALLBACK_1(set_grains,t_int)
+  FLEXT_CALLBACK_1(set_offset,t_int)
+  FLEXT_CALLBACK(set_reverse)
+    
+  t_int grains;
+  t_int grainsize;
+  t_int offset;
+  
+  t_int bs; //blocksize
+  t_int bs1; //bs+1
+  t_int counter;
+
+  t_sample * data; //array with data
+  t_sample * d1; //1. element in array with data
+  t_sample * dend; //1 element after the last element
+  
+  t_sample * ins;
+  t_sample * outs;
+
+  bool reverse;
+  
+};
+
+
+FLEXT_LIB_DSP_1("fftgrsort~",fftgrsort,int)
+
+fftgrsort::fftgrsort(int arg):
+  grains(1),offset(0),counter(1),reverse(0)
+{
+  bs=arg/2;
+  grainsize=bs;
+  bs1=bs+1;
+  post("blocksize: %i",bs);
+  
+  data = new t_sample[bs+1];
+  
+  data[0]=0;
+  d1=data+1;
+  dend=data+bs+1;
+  
+  AddInSignal();
+  AddOutSignal();
+  FLEXT_ADDMETHOD_I(0,"grains",set_grains);
+  FLEXT_ADDMETHOD_I(0,"offset",set_offset);
+  FLEXT_ADDMETHOD_(0,"reverse",set_reverse);
+} 
+
+void fftgrsort::m_signal(int n, t_float * const *in, t_float *const *out)
+{
+  ins = in[0];
+  outs = out[0];
+
+
+  if (offset>0)
+    {
+      CopySamples(d1+bs-offset,ins,offset);
+      CopySamples(d1,ins+offset,bs-offset);
+    }
+  else if (offset<0)
+    {
+      CopySamples(d1-offset,ins,bs+offset);
+      CopySamples(d1,ins+bs+offset,-offset);
+    } 
+  else 
+    CopySamples(data,ins,bs1);
+  
+  
+  //grains
+  
+  counter=1;
+  
+  while (counter!=grains) 
+    {
+      std::sort(d1+grainsize*(counter-1),d1+grainsize*counter);
+      if (reverse)
+	std::reverse(d1+grainsize*(counter-1),d1+grainsize*counter);
+      ++counter;
+    }
+  
+  std::sort(d1+grainsize*(counter-1),dend);
+  if (reverse)
+    std::reverse(d1+grainsize*(counter-1),dend);
+
+  
+  CopySamples(outs,data,bs1);
+}
+
+void fftgrsort::set_offset(t_int o)
+{
+  if (o-bs<0 && o+bs>0)
+    {
+      offset=-o;
+      post("offset %i",o);
+    }
+  else
+    post("offset out of range!");
+}
+
+
+void fftgrsort::set_grains(t_int g)
+{
+  if (  (g > 0) )
+    {
+      grains=g;
+      grainsize=(bs)/grains;
+    }
+}
+
+void fftgrsort::set_reverse()
+{
+  reverse=!reverse;
+}
+
+
diff --git a/tbext/source/main.cpp b/tbext/source/main.cpp
index bd6d833..4b204f6 100644
--- a/tbext/source/main.cpp
+++ b/tbext/source/main.cpp
@@ -56,6 +56,7 @@ void ttbext_setup()
   FLEXT_SETUP(tbroute);
   //FLEXT_SETUP(tbstrg);
   FLEXT_DSP_SETUP(tbsroute);
+  FLEXT_DSP_SETUP(tbssel);
   FLEXT_DSP_SETUP(tbsig);
   FLEXT_DSP_SETUP(tbpow);
   //  FLEXT_DSP_SETUP(tbg7xx);
diff --git a/tbext/source/tbfft2.cpp b/tbext/source/tbfft2.cpp
new file mode 100644
index 0000000..6ed71d9
--- /dev/null
+++ b/tbext/source/tbfft2.cpp
@@ -0,0 +1,147 @@
+/* Copyright (c) 2003 Tim Blechmann.                                            */
+/* For information on usage and redistribution, and for a DISCLAIMER OF ALL     */
+/* WARRANTIES, see the file, "COPYING"  in this distribution.                   */
+/*                                                                              */
+/*                                                                              */
+/* tbfft2~ transforms the fft spectrum. it reverses the order of the samples in */
+/* the fft spectrum. see the help file for further instruction...               */
+/*                                                                              */
+/*                                                                              */
+/* tbfft2~ uses the flext C++ layer for Max/MSP and PD externals.               */
+/* get it at http://www.parasitaere-kapazitaeten.de/PD/ext                      */
+/* thanks to Thomas Grill                                                       */
+/*                                                                              */
+/*                                                                              */
+/*                                                                              */
+/* 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.                       */
+/*                                                                              */
+/* See file LICENSE for further informations on licensing terms.                */
+/*                                                                              */
+/* 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.  */
+/*                                                                              */
+/* Based on PureData by Miller Puckette and others.                             */
+/*                                                                              */
+/*                                                                              */
+/*                                                                              */
+/* coded while listening to: Naked City: Heretic, Jeux Des Dames Cruelles       */
+/*                           Bob Ostertag: Attention Span                       */
+/*                                                                              */
+/*                                                                              */
+
+
+
+#include <flext.h>
+
+#if !defined(FLEXT_VERSION) || (FLEXT_VERSION < 401)
+#error upgrade your flext version!!!!!!
+#endif
+
+
+class tbfft2: public flext_dsp
+{
+  FLEXT_HEADER(tbfft2,flext_dsp);
+
+public: // constructor
+  tbfft2();
+
+protected:
+  virtual void m_signal (int n, float *const *in, float *const *out);
+  void set_freq(t_float);
+  void set_width(t_float);
+
+private:
+  FLEXT_CALLBACK_1(set_freq,t_float)
+  FLEXT_CALLBACK_1(set_width,t_float)
+  
+  t_int center;
+  t_int width;
+  
+  t_float pos;
+  t_int posi;
+
+  float *ins;
+  float *outs;
+  float *tmps;
+  t_float tmp[2049];
+  
+  t_float s;
+  t_float b;
+  
+  t_int n0;
+};
+
+
+FLEXT_LIB_DSP("tbfft2~",tbfft2)
+
+tbfft2::tbfft2()
+{
+  AddInSignal();
+  AddOutSignal();
+  FLEXT_ADDMETHOD_F(0,"center",set_freq);
+  FLEXT_ADDMETHOD_F(0,"width",set_width);
+} 
+
+
+void tbfft2::m_signal(int n, t_float *const *in, t_float *const *out)
+{
+  ins = in[0];
+  outs = out[0];
+
+  CopySamples(tmp,ins,n);
+  
+  n0=n/2;  
+
+  if (center-width>0)
+    {
+      n=center-width;
+    }
+  else
+    n=0;
+  
+  while (n<center+width)
+    {
+      tmp[n]=*(ins+2*center-n);
+      ++n;
+    }
+  
+
+
+  //memcp
+  CopySamples(outs,tmp,n0*2);
+  
+}
+
+void tbfft2::set_freq(t_float freq)
+{
+  center=freq;
+  set_width(width);
+}
+
+void tbfft2::set_width(t_float w)
+{
+
+  if (w+center>n0)
+    {
+      width=n0-center;
+      return;
+    }
+  if (center-w<0)
+    {
+      width=center;
+      return;
+    }
+
+  width=w;
+}
+
+