* all: first implementation of a MilkDrop-compatible visualization plugin,
authorCyril Deguet <asmax@videolan.org>
Sat, 17 Jul 2004 13:55:48 +0000 (13:55 +0000)
committerCyril Deguet <asmax@videolan.org>
Sat, 17 Jul 2004 13:55:48 +0000 (13:55 +0000)
    based on ProjectM (xmms-projectm.sourceforge.net), without the
    dependency on SDL 1.3. At the moment it only works on X11 with GLX 1.3,
    I didn't manage to have it working with the 1.2 API :(
    SGI Pbuffers are not used yet, I didn't manage to have them working
    well either :(
    Milkdrop presets are searched in /etc/projectM/presets (guess why ;)
    With projectM presets, colours look a bit "flashy", I wonder if it
    is normal...
    To compile the plugin, add --enable-galaktos in configure. The only
    dependencies are on X11 and OpenGL libs.
    Enjoy !

58 files changed:
modules/visualization/galaktos/Modules.am
modules/visualization/galaktos/PCM.c [new file with mode: 0644]
modules/visualization/galaktos/PCM.h [new file with mode: 0644]
modules/visualization/galaktos/beat_detect.c [new file with mode: 0644]
modules/visualization/galaktos/beat_detect.h [new file with mode: 0644]
modules/visualization/galaktos/builtin_funcs.c [new file with mode: 0644]
modules/visualization/galaktos/builtin_funcs.h [new file with mode: 0644]
modules/visualization/galaktos/common.h [new file with mode: 0644]
modules/visualization/galaktos/compare.h [new file with mode: 0644]
modules/visualization/galaktos/custom_shape.c [new file with mode: 0644]
modules/visualization/galaktos/custom_shape.h [new file with mode: 0644]
modules/visualization/galaktos/custom_shape_types.h [new file with mode: 0644]
modules/visualization/galaktos/custom_wave.c [new file with mode: 0644]
modules/visualization/galaktos/custom_wave.h [new file with mode: 0644]
modules/visualization/galaktos/custom_wave_types.h [new file with mode: 0644]
modules/visualization/galaktos/engine_vars.c [new file with mode: 0644]
modules/visualization/galaktos/engine_vars.h [new file with mode: 0644]
modules/visualization/galaktos/eval.c [new file with mode: 0644]
modules/visualization/galaktos/eval.h [new file with mode: 0644]
modules/visualization/galaktos/expr_types.h [new file with mode: 0644]
modules/visualization/galaktos/fatal.h [new file with mode: 0644]
modules/visualization/galaktos/fftsg.c [new file with mode: 0644]
modules/visualization/galaktos/func.c [new file with mode: 0644]
modules/visualization/galaktos/func.h [new file with mode: 0644]
modules/visualization/galaktos/func_types.h [new file with mode: 0644]
modules/visualization/galaktos/glx.c
modules/visualization/galaktos/glx.h
modules/visualization/galaktos/idle_preset.h [new file with mode: 0644]
modules/visualization/galaktos/init_cond.c [new file with mode: 0644]
modules/visualization/galaktos/init_cond.h [new file with mode: 0644]
modules/visualization/galaktos/init_cond_types.h [new file with mode: 0644]
modules/visualization/galaktos/interface_types.h [new file with mode: 0644]
modules/visualization/galaktos/main.c
modules/visualization/galaktos/main.h
modules/visualization/galaktos/param.c [new file with mode: 0644]
modules/visualization/galaktos/param.h [new file with mode: 0644]
modules/visualization/galaktos/param_types.h [new file with mode: 0644]
modules/visualization/galaktos/parser.c [new file with mode: 0644]
modules/visualization/galaktos/parser.h [new file with mode: 0644]
modules/visualization/galaktos/per_frame_eqn.c [new file with mode: 0644]
modules/visualization/galaktos/per_frame_eqn.h [new file with mode: 0644]
modules/visualization/galaktos/per_frame_eqn_types.h [new file with mode: 0644]
modules/visualization/galaktos/per_pixel_eqn.c [new file with mode: 0644]
modules/visualization/galaktos/per_pixel_eqn.h [new file with mode: 0644]
modules/visualization/galaktos/per_pixel_eqn_types.h [new file with mode: 0644]
modules/visualization/galaktos/per_point_types.h [new file with mode: 0644]
modules/visualization/galaktos/plugin.c
modules/visualization/galaktos/plugin.h
modules/visualization/galaktos/preset.c [new file with mode: 0644]
modules/visualization/galaktos/preset.h [new file with mode: 0644]
modules/visualization/galaktos/preset_types.h [new file with mode: 0644]
modules/visualization/galaktos/splaytree.c [new file with mode: 0644]
modules/visualization/galaktos/splaytree.h [new file with mode: 0644]
modules/visualization/galaktos/splaytree_types.h [new file with mode: 0644]
modules/visualization/galaktos/tree_types.c [new file with mode: 0644]
modules/visualization/galaktos/tree_types.h [new file with mode: 0644]
modules/visualization/galaktos/video_init.c [new file with mode: 0644]
modules/visualization/galaktos/video_init.h [new file with mode: 0644]

index 906e2a1..937e7df 100644 (file)
@@ -3,4 +3,23 @@ SOURCES_galaktos = plugin.c \
                    glx.c \
                    glx.h \
                    main.c \
-                   main.h
+                   main.h \
+                   preset.c \
+                   preset.h \
+                   beat_detect.c \
+                   param.c \
+                   engine_vars.c \
+                   parser.c \
+                   builtin_funcs.c \
+                   eval.c \
+                   init_cond.c \
+                   PCM.c \
+                   fftsg.c \
+                   per_frame_eqn.c \
+                   splaytree.c \
+                   custom_shape.c \
+                   func.c \
+                   per_pixel_eqn.c \
+                   tree_types.c \
+                   custom_wave.c \
+                   video_init.c
diff --git a/modules/visualization/galaktos/PCM.c b/modules/visualization/galaktos/PCM.c
new file mode 100644 (file)
index 0000000..14e8be4
--- /dev/null
@@ -0,0 +1,199 @@
+/*****************************************************************************
+ * PCM.c:
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id$
+ *
+ * Authors: Cyril Deguet <asmax@videolan.org>
+ *          code from projectM http://xmms-projectm.sourceforge.net
+ *
+ * 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, USA.
+ *****************************************************************************/
+
+
+//PCM.c - Sound data handler
+//
+//by Peter Sperl
+//
+//Takes sound data from wherever and hands it back out.
+//Returns PCM Data or spectrum data, or the derivative of the PCM data
+
+#include <stdlib.h>
+#include <stdio.h>
+
+double **PCMd;    //data structure to store PCM data  PCM[channels][maxsamples]
+int maxsamples;   //size of PCM buffer
+int start;        //where to add data next
+
+int *ip;          //working space for FFT routines
+double *w;        //lookup table for FFT routines
+int new;          //how many new samples
+
+
+//initPCM(int samples)
+//
+//Initializes the PCM buffer to
+// number of samples specified.
+
+void initPCM(int samples)
+{
+  int i; 
+
+  //Allocate memory for PCM data buffer
+  PCMd = (double **)malloc(2 * sizeof(double *));
+  PCMd[0] = (double *)malloc(samples * sizeof(double));
+  PCMd[1] = (double *)malloc(samples * sizeof(double));
+  
+  maxsamples=samples;
+  new=0;
+
+  //Initialize buffers to 0
+  for (i=0;i<samples;i++)
+    {
+      PCMd[0][i]=0;
+      PCMd[1][i]=0;
+    }
+
+  start=0;
+
+  //Allocate FFT workspace
+  w=  (double *)malloc(maxsamples*sizeof(double));
+  ip= (int *)malloc(maxsamples*sizeof(int));
+  ip[0]=0;
+}
+
+//The only current addPCM function, can support more
+//
+//Takes in a 2x512 array of PCM samples
+//and stores them
+
+void addPCM(int16_t PCMdata[2][512])
+{
+  int i,j;
+  int samples=512;
+
+        for(i=0;i<samples;i++)
+          {
+            j=i+start;
+            PCMd[0][j%maxsamples]=(PCMdata[0][i]/16384.0);
+            PCMd[1][j%maxsamples]=(PCMdata[1][i]/16384.0);  
+          }
+       
+        // printf("Added %d samples %d %d %f\n",samples,start,(start+samples)%maxsamples,PCM[0][start+10]); 
+
+ start+=samples;
+ start=start%maxsamples;
+
+ new+=samples;
+ if (new>maxsamples) new=maxsamples;
+}
+
+
+//puts sound data requested at provided pointer
+//
+//samples is number of PCM samples to return
+//freq = 0 gives PCM data
+//freq = 1 gives FFT data
+//smoothing is the smoothing coefficient
+
+//returned values are normalized from -1 to 1
+
+void getPCM(double *PCMdata, int samples, int channel, int freq, double smoothing, int derive)
+{
+   int i,index;
+   
+   index=start-1;
+
+   if (index<0) index=maxsamples+index;
+
+   PCMdata[0]=PCMd[channel][index];
+   
+   for(i=1;i<samples;i++)
+     {
+       index=start-1-i;
+       if (index<0) index=maxsamples+index;
+       
+       PCMdata[i]=(1-smoothing)*PCMd[channel][index]+smoothing*PCMdata[i-1];
+     }
+   
+   //return derivative of PCM data
+   if(derive)
+     {
+       for(i=0;i<samples-1;i++)
+        {         
+          PCMdata[i]=PCMdata[i]-PCMdata[i+1];
+        }
+       PCMdata[samples-1]=0;
+     }
+
+   //return frequency data instead of PCM (perform FFT)
+   if (freq) rdft(samples, 1, PCMdata, ip, w);
+
+
+     
+}
+
+//getPCMnew
+//
+//Like getPCM except it returns all new samples in the buffer
+//the actual return value is the number of samples, up to maxsamples.
+//the passed pointer, PCMData, must bee able to hold up to maxsamples
+
+int getPCMnew(double *PCMdata, int channel, int freq, double smoothing, int derive, int reset)
+{
+   int i,index;
+   
+   index=start-1;
+
+   if (index<0) index=maxsamples+index;
+
+   PCMdata[0]=PCMd[channel][index];
+   
+   for(i=1;i<new;i++)
+     {
+       index=start-1-i;
+       if (index<0) index=maxsamples+index;
+       
+       PCMdata[i]=(1-smoothing)*PCMd[channel][index]+smoothing*PCMdata[i-1];
+     }
+   
+   //return derivative of PCM data
+   if(derive)
+     {
+       for(i=0;i<new-1;i++)
+        {         
+          PCMdata[i]=PCMdata[i]-PCMdata[i+1];
+        }
+       PCMdata[new-1]=0;
+     }
+
+   //return frequency data instead of PCM (perform FFT)
+   //   if (freq) rdft(samples, 1, PCMdata, ip, w);
+   i=new;
+   if (reset)  new=0;
+
+   return i;
+}
+
+//Free stuff
+void freePCM()
+{
+  free(PCMd[0]);
+  free(PCMd[1]);
+  free(PCMd);
+  free(ip);
+  free(w);
+}
diff --git a/modules/visualization/galaktos/PCM.h b/modules/visualization/galaktos/PCM.h
new file mode 100644 (file)
index 0000000..9b3607b
--- /dev/null
@@ -0,0 +1,6 @@
+
+void initPCM(int maxsamples);
+void addPCM(int16_t [2][512]);
+void getPCM(double *data, int samples, int channel, int freq, double smoothing, int derive);
+void freePCM();
+int getPCMnew(double *PCMdata, int channel, int freq, double smoothing, int derive,int reset);
diff --git a/modules/visualization/galaktos/beat_detect.c b/modules/visualization/galaktos/beat_detect.c
new file mode 100644 (file)
index 0000000..03f2258
--- /dev/null
@@ -0,0 +1,148 @@
+/*****************************************************************************
+ * beat_detect.c: basic beat detection algorithm
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id$
+ *
+ * Authors: Cyril Deguet <asmax@videolan.org>
+ *          code from projectM http://xmms-projectm.sourceforge.net
+ *
+ * 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, USA.
+ *****************************************************************************/
+
+//
+//by Peter Sperl
+//
+//Takes sound data from wherever and returns beat detection values
+//Uses statistical Energy-Based methods. Very simple
+//
+//Some stuff was taken from Frederic Patin's beat-detection article, you'll find it online
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "engine_vars.h"
+
+double beat_buffer[32][80],beat_instant[32],beat_history[32];
+double *beat_val,*beat_att,*beat_variance;
+int beat_buffer_pos;
+
+double vol_buffer[80],vol_instant,vol_history;
+
+void initBeatDetect()
+{
+
+  int x,y; 
+
+  vol_instant=0;
+  vol_history=0;
+
+  for (y=0;y<80;y++)
+    {
+      vol_buffer[y]=0;
+    }
+
+  beat_buffer_pos=0;
+
+  beat_val=(double *)malloc(32*sizeof(double));
+  beat_att=(double *)malloc(32*sizeof(double));
+  beat_variance=(double *)malloc(32*sizeof(double));
+
+  for (x=0;x<32;x++)
+    {
+      beat_instant[x]=0;
+      beat_history[x]=0;
+      beat_val[x]=1.0;
+      beat_att[x]=1.0;
+      beat_variance[x]=0;
+      for (y=0;y<80;y++)
+       {
+         beat_buffer[x][y]=0;
+       }
+    }
+
+} 
+
+void getBeatVals(double *vdataL,double *vdataR, double *vol)
+{
+  int linear=0;
+  int x,y;
+
+  vol_instant=0;
+
+      for ( x=0;x<16;x++)
+       {
+         
+         beat_instant[x]=0;
+         for ( y=linear*2;y<(linear+8+x)*2;y++)
+           {
+             beat_instant[x]+=((vdataL[y]*vdataL[y])+(vdataR[y]*vdataR[y]))*(1.0/(8+x)); 
+             vol_instant+=((vdataL[y]*vdataL[y])+(vdataR[y]*vdataR[y]))*(1.0/512.0);
+
+           }
+         
+         linear=y/2;
+         beat_history[x]-=(beat_buffer[x][beat_buffer_pos])*.0125;
+         beat_buffer[x][beat_buffer_pos]=beat_instant[x];
+         beat_history[x]+=(beat_instant[x])*.0125;
+         
+         beat_val[x]=(beat_instant[x])/(beat_history[x]);
+         
+         beat_att[x]+=(beat_instant[x])/(beat_history[x]);
+
+
+         
+       }
+      
+      vol_history-=(vol_buffer[beat_buffer_pos])*.0125;
+      vol_buffer[beat_buffer_pos]=vol_instant;
+      vol_history+=(vol_instant)*.0125;
+
+      double temp2=0;
+      mid=0;
+      for(x=1;x<10;x++)
+       {
+        mid+=(beat_instant[x]);
+         temp2+=(beat_history[x]);
+        
+       }
+       
+        mid=mid/(1.5*temp2);
+        temp2=0;
+        treb=0;
+         for(x=10;x<16;x++)
+           { 
+             treb+=(beat_instant[x]);
+             temp2+=(beat_history[x]);
+           }
+         treb=treb/(1.5*temp2);
+         *vol=vol_instant/(1.5*vol_history);
+  
+         bass=(beat_instant[0])/(1.5*beat_history[0]);
+
+         treb_att=.6 * treb_att + .4 * treb;
+         mid_att=.6 * mid_att + .4 * mid;
+         bass_att=.6 * bass_att + .4 * bass;
+         //printf("%f %f %f %f\n",bass,mid,treb,*vol);
+          // *vol=(beat_instant[3])/(beat_history[3]);
+         beat_buffer_pos++;
+         if( beat_buffer_pos>79)beat_buffer_pos=0;
+       
+}
+void freeBeatDetect()
+{
+  free(beat_att);
+  free(beat_val);
+  free(beat_variance);
+}
diff --git a/modules/visualization/galaktos/beat_detect.h b/modules/visualization/galaktos/beat_detect.h
new file mode 100644 (file)
index 0000000..c673cc1
--- /dev/null
@@ -0,0 +1,5 @@
+
+
+void initBeatDetect();
+void getBeatVals(double *vdataL,double *vdataR,double *vol);
+void freeBeatDetect();
diff --git a/modules/visualization/galaktos/builtin_funcs.c b/modules/visualization/galaktos/builtin_funcs.c
new file mode 100644 (file)
index 0000000..16086d3
--- /dev/null
@@ -0,0 +1,206 @@
+/*****************************************************************************
+ * builtin_funcs.c:
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id$
+ *
+ * Authors: Cyril Deguet <asmax@videolan.org>
+ *          code from projectM http://xmms-projectm.sourceforge.net
+ *
+ * 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, USA.
+ *****************************************************************************/
+
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+/* Values to optimize the sigmoid function */
+#define R  32767   
+#define RR 65534   
+inline double int_wrapper(double * arg_list) {
+
+  return floor(arg_list[0]);
+
+}
+
+
+inline double sqr_wrapper(double * arg_list) {
+       
+       return pow(2, arg_list[0]);
+}      
+       
+       
+inline double sign_wrapper(double * arg_list) {        
+       
+       return -arg_list[0];    
+}      
+
+inline double min_wrapper(double * arg_list) {
+       
+       if (arg_list[0] > arg_list[1])
+               return arg_list[1];
+       
+       return arg_list[0];
+}              
+
+inline double max_wrapper(double * arg_list) {
+
+       if (arg_list[0] > arg_list[1])
+         return arg_list[0];
+
+       return arg_list[1];
+}
+
+/* consult your AI book */
+inline double sigmoid_wrapper(double * arg_list) {
+  return (RR / (1 + exp( -(((double)(arg_list[0])) * arg_list[1]) / R) - R));
+}
+       
+       
+inline double bor_wrapper(double * arg_list) {
+
+       return (double)((int)arg_list[0] || (int)arg_list[1]);
+}      
+       
+inline double band_wrapper(double * arg_list) {
+       return (double)((int)arg_list[0] && (int)arg_list[1]);
+}      
+
+inline double bnot_wrapper(double * arg_list) {
+       return (double)(!(int)arg_list[0]);
+}              
+
+inline double if_wrapper(double * arg_list) {
+
+               if ((int)arg_list[0] == 0)
+                       return arg_list[2];
+               return arg_list[1];
+}              
+
+
+inline double rand_wrapper(double * arg_list) {
+  double l;
+
+  //  printf("RAND ARG:(%d)\n", (int)arg_list[0]);
+  l = (double)((rand()) % ((int)arg_list[0]));
+  //printf("VAL: %f\n", l);
+  return l;
+}      
+
+inline double equal_wrapper(double * arg_list) {
+
+       return (arg_list[0] == arg_list[1]);
+}      
+
+
+inline double above_wrapper(double * arg_list) {
+
+       return (arg_list[0] > arg_list[1]);
+}      
+
+
+inline double below_wrapper(double * arg_list) {
+
+       return (arg_list[0] < arg_list[1]);
+}
+
+inline double sin_wrapper(double * arg_list) {
+       return (sin (arg_list[0]));     
+}
+
+
+inline double cos_wrapper(double * arg_list) {
+       return (cos (arg_list[0]));
+}
+
+inline double tan_wrapper(double * arg_list) {
+       return (tan(arg_list[0]));
+}
+
+inline double asin_wrapper(double * arg_list) {
+       return (asin (arg_list[0]));
+}
+
+inline double acos_wrapper(double * arg_list) {
+       return (acos (arg_list[0]));
+}
+
+inline double atan_wrapper(double * arg_list) {
+       return (atan (arg_list[0]));
+}
+
+inline double atan2_wrapper(double * arg_list) {
+  return (atan2 (arg_list[0], arg_list[1]));
+}
+
+inline double pow_wrapper(double * arg_list) {
+  return (pow (arg_list[0], arg_list[1]));
+}
+
+inline double exp_wrapper(double * arg_list) {
+  return (exp(arg_list[0]));
+}
+
+inline double abs_wrapper(double * arg_list) {
+  return (fabs(arg_list[0]));
+}
+
+inline double log_wrapper(double *arg_list) {
+  return (log (arg_list[0]));
+}
+
+inline double log10_wrapper(double * arg_list) {
+  return (log10 (arg_list[0]));
+}
+
+inline double sqrt_wrapper(double * arg_list) {
+  return (sqrt (arg_list[0]));
+}
+
+
+inline double nchoosek_wrapper(double * arg_list) {
+      unsigned long cnm = 1UL;
+      int i, f;
+      int n, m;
+
+      n = (int)arg_list[0];
+      m = (int)arg_list[1];
+
+      if (m*2 >n) m = n-m;
+      for (i=1 ; i <= m; n--, i++)
+      {
+            if ((f=n) % i == 0)
+                  f   /= i;
+            else  cnm /= i;
+            cnm *= f;
+      }
+      return (double)cnm;
+}
+
+
+inline double fact_wrapper(double * arg_list) {
+
+
+  int result = 1;
+  
+  int n = (int)arg_list[0];
+  
+  while (n > 1) {
+    result = result * n;
+    n--;
+  }
+  return (double)result;
+}
diff --git a/modules/visualization/galaktos/builtin_funcs.h b/modules/visualization/galaktos/builtin_funcs.h
new file mode 100644 (file)
index 0000000..a181684
--- /dev/null
@@ -0,0 +1,35 @@
+/* Wrappers for all the builtin functions 
+   The arg_list pointer is a list of doubles. Its
+   size is equal to the number of arguments the parameter
+   takes */
+inline double below_wrapper(double * arg_list);
+inline double above_wrapper(double * arg_list);
+inline double equal_wrapper(double * arg_list);
+inline double if_wrapper(double * arg_list);
+inline double bnot_wrapper(double * arg_list);
+inline double rand_wrapper(double * arg_list);
+inline double bor_wrapper(double * arg_list);
+inline double band_wrapper(double * arg_list);
+inline double sigmoid_wrapper(double * arg_list);
+inline double max_wrapper(double * arg_list);
+inline double min_wrapper(double * arg_list);
+inline double sign_wrapper(double * arg_list);
+inline double sqr_wrapper(double * arg_list);
+inline double int_wrapper(double * arg_list);
+inline double nchoosek_wrapper(double * arg_list);
+inline double sin_wrapper(double * arg_list);
+inline double cos_wrapper(double * arg_list);
+inline double tan_wrapper(double * arg_list);
+inline double fact_wrapper(double * arg_list);
+inline double asin_wrapper(double * arg_list);
+inline double acos_wrapper(double * arg_list);
+inline double atan_wrapper(double * arg_list);
+inline double atan2_wrapper(double * arg_list);
+
+inline double pow_wrapper(double * arg_list);
+inline double exp_wrapper(double * arg_list);
+inline double abs_wrapper(double * arg_list);
+inline double log_wrapper(double *arg_list);
+inline double log10_wrapper(double * arg_list);
+inline double sqrt_wrapper(double * arg_list);
diff --git a/modules/visualization/galaktos/common.h b/modules/visualization/galaktos/common.h
new file mode 100644 (file)
index 0000000..560a6cc
--- /dev/null
@@ -0,0 +1,31 @@
+#ifndef COMMON_H
+#define COMMON_H
+
+#define DEFAULT_FONT_PATH "/home/carm/fonts/courier1.glf"
+#define MAX_TOKEN_SIZE 512
+#define MAX_PATH_SIZE 4096
+
+#define STRING_BUFFER_SIZE 1024*150
+#define STRING_LINE_SIZE 1024
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+#ifndef FALSE
+#define FALSE 0
+#endif 
+
+#define PROJECTM_FILE_EXTENSION ".prjm"
+#define MILKDROP_FILE_EXTENSION ".milk"
+
+#define MAX_DOUBLE_SIZE  10000000.0
+#define MIN_DOUBLE_SIZE -10000000.0
+
+#define MAX_INT_SIZE  10000000
+#define MIN_INT_SIZE -10000000
+
+#define DEFAULT_DOUBLE_IV 0.0 /* default double initial value */
+#define DEFAULT_DOUBLE_LB MIN_DOUBLE_SIZE /* default double lower bound */
+#define DEFAULT_DOUBLE_UB MAX_DOUBLE_SIZE /* default double upper bound */
+
+#endif
diff --git a/modules/visualization/galaktos/compare.h b/modules/visualization/galaktos/compare.h
new file mode 100644 (file)
index 0000000..851aad3
--- /dev/null
@@ -0,0 +1,3 @@
+
+int compare_int(int * num1, int * num2);
+int compare_string(char * string1, char * string2);
diff --git a/modules/visualization/galaktos/custom_shape.c b/modules/visualization/galaktos/custom_shape.c
new file mode 100644 (file)
index 0000000..d85dfa7
--- /dev/null
@@ -0,0 +1,607 @@
+/*****************************************************************************
+ * custom_shape.c:
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id$
+ *
+ * Authors: Cyril Deguet <asmax@videolan.org>
+ *          code from projectM http://xmms-projectm.sourceforge.net
+ *
+ * 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, USA.
+ *****************************************************************************/
+
+//
+
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "common.h"
+#include "fatal.h"
+
+#include "param_types.h"
+#include "param.h"
+
+#include "expr_types.h"
+#include "eval.h"
+
+#include "splaytree_types.h"
+#include "splaytree.h"
+#include "tree_types.h"
+
+#include "per_frame_eqn_types.h"
+#include "per_frame_eqn.h"
+
+#include "init_cond_types.h"
+#include "init_cond.h"
+
+#include "preset_types.h"
+
+#include "custom_shape_types.h"
+#include "custom_shape.h"
+
+#include "init_cond_types.h"
+#include "init_cond.h"
+
+custom_shape_t * interface_shape = NULL;
+int cwave_interface_id = 0;
+extern preset_t * active_preset;
+inline void eval_custom_shape_init_conds(custom_shape_t * custom_shape);
+void load_unspec_init_cond_shape(param_t * param);
+
+void destroy_param_db_tree_shape(splaytree_t * tree);
+void destroy_per_frame_eqn_tree_shape(splaytree_t * tree);
+void destroy_per_frame_init_eqn_tree_shape(splaytree_t * tree);
+void destroy_init_cond_tree_shape(splaytree_t * tree);
+
+custom_shape_t * new_custom_shape(int id) {
+
+  custom_shape_t * custom_shape;
+  param_t * param;
+
+  if ((custom_shape = (custom_shape_t*)malloc(sizeof(custom_shape_t))) == NULL)
+    return NULL;
+
+  custom_shape->id = id;
+  custom_shape->per_frame_count = 0;
+  custom_shape->per_frame_eqn_string_index = 0;
+  custom_shape->per_frame_init_eqn_string_index = 0;
+
+  /* Initialize tree data structures */
+
+  if ((custom_shape->param_tree = 
+       create_splaytree(compare_string, copy_string, free_string)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((custom_shape->per_frame_eqn_tree = 
+       create_splaytree(compare_int, copy_int, free_int)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((custom_shape->init_cond_tree = 
+       create_splaytree(compare_string, copy_string, free_string)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+  
+  if ((custom_shape->per_frame_init_eqn_tree = 
+       create_splaytree(compare_string, copy_string, free_string)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  /* Start: Load custom shape parameters */
+
+  if ((param = new_param_double("r", P_FLAG_NONE, &custom_shape->r, NULL, 1.0, 0.0, .5)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+  if ((param = new_param_double("g", P_FLAG_NONE, &custom_shape->g, NULL, 1.0, 0.0, .5)) == NULL){
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_double("b", P_FLAG_NONE, &custom_shape->b, NULL, 1.0, 0.0, .5)) == NULL){
+    free_custom_shape(custom_shape);
+    return NULL;                                      
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_double("a", P_FLAG_NONE, &custom_shape->a, NULL, 1.0, 0.0, .5)) == NULL){
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_double("border_r", P_FLAG_NONE, &custom_shape->border_r, NULL, 1.0, 0.0, .5)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+  if ((param = new_param_double("border_g", P_FLAG_NONE, &custom_shape->border_g, NULL, 1.0, 0.0, .5)) == NULL){
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_double("border_b", P_FLAG_NONE, &custom_shape->border_b, NULL, 1.0, 0.0, .5)) == NULL){
+    free_custom_shape(custom_shape);
+    return NULL;                                      
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_double("border_a", P_FLAG_NONE, &custom_shape->border_a, NULL, 1.0, 0.0, .5)) == NULL){
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_double("r2", P_FLAG_NONE, &custom_shape->r2, NULL, 1.0, 0.0, .5)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+  if ((param = new_param_double("g2", P_FLAG_NONE, &custom_shape->g2, NULL, 1.0, 0.0, .5)) == NULL){
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_double("b2", P_FLAG_NONE, &custom_shape->b2, NULL, 1.0, 0.0, .5)) == NULL){
+    free_custom_shape(custom_shape);
+    return NULL;                                      
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_double("a2", P_FLAG_NONE, &custom_shape->a2, NULL, 1.0, 0.0, .5)) == NULL){
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+  
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_double("x", P_FLAG_NONE, &custom_shape->x, NULL, 1.0, 0.0, .5)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_double("y", P_FLAG_NONE, &custom_shape->y, NULL, 1.0, 0.0, .5)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_bool("thickOutline", P_FLAG_NONE, &custom_shape->thickOutline, 1, 0, 0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_bool("enabled", P_FLAG_NONE, &custom_shape->enabled, 1, 0, 0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_int("sides", P_FLAG_NONE, &custom_shape->sides, 100, 3, 3)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_bool("additive", P_FLAG_NONE, &custom_shape->additive, 1, 0, 0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_bool("textured", P_FLAG_NONE, &custom_shape->textured, 1, 0, 0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+   if ((param = new_param_double("rad", P_FLAG_NONE, &custom_shape->rad, NULL, MAX_DOUBLE_SIZE, 0, 0.0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+   if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+   if ((param = new_param_double("ang", P_FLAG_NONE, &custom_shape->ang, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+   if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+   if ((param = new_param_double("tex_zoom", P_FLAG_NONE, &custom_shape->tex_zoom, NULL, MAX_DOUBLE_SIZE, .00000000001, 0.0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+   if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+   
+   if ((param = new_param_double("tex_ang", P_FLAG_NONE, &custom_shape->tex_ang, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+   if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+   if ((param = new_param_double("t1", P_FLAG_TVAR, &custom_shape->t1, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_double("t2", P_FLAG_TVAR, &custom_shape->t2, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_double("t3", P_FLAG_TVAR, &custom_shape->t3, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+  if ((param = new_param_double("t4", P_FLAG_TVAR, &custom_shape->t4, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+  if ((param = new_param_double("t5", P_FLAG_TVAR, &custom_shape->t5, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+  if ((param = new_param_double("t6", P_FLAG_TVAR, &custom_shape->t6, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+  if ((param = new_param_double("t7", P_FLAG_TVAR, &custom_shape->t7, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if ((param = new_param_double("t8", P_FLAG_TVAR, &custom_shape->t8, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_shape->param_tree) < 0) {
+    free_custom_shape(custom_shape);
+    return NULL;
+  }
+  /* End of parameter loading. Note that the read only parameters associated
+     with custom shapes (ie, sample) are global variables, and not specific to 
+     the custom shape datastructure. */
+
+
+
+  return custom_shape;
+
+}
+
+void destroy_per_frame_init_eqn_tree_shape(splaytree_t * tree) {
+
+  if (!tree)
+    return;
+
+  splay_traverse(free_init_cond, tree);
+  destroy_splaytree(tree);
+
+}
+
+
+
+void destroy_init_cond_tree_shape(splaytree_t * tree) {
+
+  if (!tree)
+    return;
+
+  splay_traverse(free_init_cond, tree);
+  destroy_splaytree(tree);
+
+}
+
+void destroy_per_frame_eqn_tree_shape(splaytree_t * tree) {
+
+
+  if (!tree)
+    return;
+
+  splay_traverse(free_per_frame_eqn, tree);
+  destroy_splaytree(tree);
+
+}
+
+
+void destroy_param_db_tree_shape(splaytree_t * tree) {
+
+  if (!tree)
+    return;
+
+  splay_traverse(free_param, tree);
+  destroy_splaytree(tree);
+
+}
+
+/* Frees a custom shape form object */
+void free_custom_shape(custom_shape_t * custom_shape) {
+
+  if (custom_shape == NULL)
+    return;
+
+  if (custom_shape->param_tree == NULL)
+    return;
+
+  destroy_per_frame_eqn_tree_shape(custom_shape->per_frame_eqn_tree);
+  destroy_init_cond_tree_shape(custom_shape->init_cond_tree);
+  destroy_param_db_tree_shape(custom_shape->param_tree);
+  destroy_per_frame_init_eqn_tree_shape(custom_shape->per_frame_init_eqn_tree);
+  
+  free(custom_shape);
+
+  return;
+
+}
+
+
+custom_shape_t * find_custom_shape(int id, preset_t * preset, int create_flag) {
+
+  custom_shape_t * custom_shape = NULL;
+
+  if (preset == NULL)
+    return NULL;
+  
+  if ((custom_shape = splay_find(&id, preset->custom_shape_tree)) == NULL) {
+    
+    if (CUSTOM_SHAPE_DEBUG) { printf("find_custom_shape: creating custom shape (id = %d)...", id);fflush(stdout);}
+    
+    if (create_flag == FALSE) {
+      if (CUSTOM_SHAPE_DEBUG) printf("you specified not to (create flag = false), returning null\n");
+      return NULL;
+    }
+    
+    if ((custom_shape = new_custom_shape(id)) == NULL) {
+      if (CUSTOM_SHAPE_DEBUG) printf("failed...out of memory?\n");
+      return NULL;
+    }
+    
+    if (CUSTOM_SHAPE_DEBUG) { printf("success.Inserting..."); fflush(stdout);}
+    
+    if (splay_insert(custom_shape, &custom_shape->id, preset->custom_shape_tree) < 0) {
+      if (CUSTOM_SHAPE_DEBUG) printf("failed, probably a duplicated!!\n");
+      free_custom_shape(custom_shape);
+      return NULL;
+    }
+    
+    if (CUSTOM_SHAPE_DEBUG) printf("done.\n");
+  }
+  
+  return custom_shape;
+}
+
+inline void evalCustomShapeInitConditions() {
+  splay_traverse(eval_custom_shape_init_conds, active_preset->custom_shape_tree);
+
+}
+
+inline void eval_custom_shape_init_conds(custom_shape_t * custom_shape) {
+  splay_traverse(eval_init_cond, custom_shape->init_cond_tree);
+  splay_traverse(eval_init_cond, custom_shape->per_frame_init_eqn_tree);
+}
+
+
+void load_unspecified_init_conds_shape(custom_shape_t * custom_shape) {
+
+  interface_shape = custom_shape;
+  splay_traverse(load_unspec_init_cond_shape, interface_shape->param_tree);
+  interface_shape = NULL;
+}
+
+void load_unspec_init_cond_shape(param_t * param) {
+
+  init_cond_t * init_cond;
+  value_t init_val;
+
+  /* Don't count read only parameters as initial conditions */
+  if (param->flags & P_FLAG_READONLY)
+    return;
+ if (param->flags & P_FLAG_QVAR)
+    return;
+ if (param->flags & P_FLAG_TVAR)
+    return;
+ if (param->flags & P_FLAG_USERDEF)
+    return;
+
+  /* If initial condition was not defined by the preset file, force a default one
+     with the following code */
+  if ((init_cond = splay_find(param->name, interface_shape->init_cond_tree)) == NULL) {
+    
+    /* Make sure initial condition does not exist in the set of per frame initial equations */
+    if ((init_cond = splay_find(param->name, interface_shape->per_frame_init_eqn_tree)) != NULL)
+      return;
+    
+    if (param->type == P_TYPE_BOOL)
+      init_val.bool_val = 0;
+    
+    else if (param->type == P_TYPE_INT)
+      init_val.int_val = *(int*)param->engine_val;
+
+    else if (param->type == P_TYPE_DOUBLE)
+      init_val.double_val = *(double*)param->engine_val;
+
+    //printf("%s\n", param->name);
+    /* Create new initial condition */
+    if ((init_cond = new_init_cond(param, init_val)) == NULL)
+      return;
+    
+    /* Insert the initial condition into this presets tree */
+    if (splay_insert(init_cond, init_cond->param->name, interface_shape->init_cond_tree) < 0) {
+      free_init_cond(init_cond);
+      return;
+    }
+    
+  }
+}
+
+
+/* Interface function. Makes another custom shape the current
+   concern for per frame / point equations */
+inline custom_shape_t * nextCustomShape() {
+
+  if ((interface_shape = splay_find(&cwave_interface_id, active_preset->custom_shape_tree)) == NULL) {
+    cwave_interface_id = 0;
+    return NULL;
+  }
+
+  cwave_interface_id++;
+
+  /* Evaluate all per frame equations associated with this shape */
+  splay_traverse(eval_per_frame_eqn, interface_shape->per_frame_eqn_tree);
+  return interface_shape;
+}
diff --git a/modules/visualization/galaktos/custom_shape.h b/modules/visualization/galaktos/custom_shape.h
new file mode 100644 (file)
index 0000000..4e4d8a8
--- /dev/null
@@ -0,0 +1,14 @@
+#ifndef CUSTOM_SHAPE_H
+#define CUSTOM_SHAPE_H
+#define CUSTOM_SHAPE_DEBUG 0
+#include "expr_types.h"
+#include "custom_shape_types.h"
+#include "preset_types.h"
+
+void free_custom_shape(custom_shape_t * custom_shape);
+custom_shape_t * new_custom_shape(int id);
+custom_shape_t * find_custom_shape(int id, preset_t * preset, int create_flag);
+void load_unspecified_init_conds_shape(custom_shape_t * custom_shape);
+inline void evalCustomShapeInitConditions();
+inline custom_shape_t * nextCustomShape();
+#endif
diff --git a/modules/visualization/galaktos/custom_shape_types.h b/modules/visualization/galaktos/custom_shape_types.h
new file mode 100644 (file)
index 0000000..23b69e9
--- /dev/null
@@ -0,0 +1,75 @@
+#ifndef CUSTOM_SHAPE_TYPES_H
+#define CUSTOM_SHAPE_TYPES_H
+#include "common.h"
+#include "splaytree_types.h"
+#include "expr_types.h"
+
+typedef struct CUSTOM_SHAPE_T {
+
+  /* Numerical id */
+  int id;
+  int per_frame_count;
+
+  /* Parameter tree associated with this custom shape */
+  splaytree_t * param_tree;
+
+
+  /* Engine variables */
+  int sides;
+  int thickOutline;
+  int enabled;
+  int additive;
+  int textured;
+
+  double tex_zoom;
+  double tex_ang;
+  
+  double x; /* x position for per point equations */
+  double y; /* y position for per point equations */
+  double rad;
+  double ang;
+
+  double r; /* red color value */
+  double g; /* green color value */
+  double b; /* blue color value */
+  double a; /* alpha color value */
+  double r2; /* red color value */
+  double g2; /* green color value */
+  double b2; /* blue color value */
+  double a2; /* alpha color value */
+
+  double border_r; /* red color value */
+  double border_g; /* green color value */
+  double border_b; /* blue color value */
+  double border_a; /* alpha color value */
+
+  /* stupid t variables */
+  double t1;
+  double t2;
+  double t3;
+  double t4;
+  double t5;
+  double t6;
+  double t7;
+  double t8;
+
+  /* Data structure to hold per frame  / per frame init equations */
+  splaytree_t * init_cond_tree;
+  splaytree_t * per_frame_eqn_tree;
+  splaytree_t * per_frame_init_eqn_tree;
+
+  /* Denotes the index of the last character for each string buffer */
+  int per_frame_eqn_string_index;
+  int per_frame_init_eqn_string_index;
+
+  /* String buffers for per frame / per frame init equations */
+  char per_frame_eqn_string_buffer[STRING_BUFFER_SIZE];
+  char per_frame_init_eqn_string_buffer[STRING_BUFFER_SIZE];
+  /* Per point equation array */
+  
+  
+} custom_shape_t;
+
+
+#endif
diff --git a/modules/visualization/galaktos/custom_wave.c b/modules/visualization/galaktos/custom_wave.c
new file mode 100644 (file)
index 0000000..2166109
--- /dev/null
@@ -0,0 +1,744 @@
+/*****************************************************************************
+ * custom_wave.c:
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id$
+ *
+ * Authors: Cyril Deguet <asmax@videolan.org>
+ *          code from projectM http://xmms-projectm.sourceforge.net
+ *
+ * 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, USA.
+ *****************************************************************************/
+
+
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "common.h"
+#include "fatal.h"
+
+#include "param_types.h"
+#include "param.h"
+
+#include "expr_types.h"
+#include "eval.h"
+
+#include "splaytree_types.h"
+#include "splaytree.h"
+#include "tree_types.h"
+
+#include "per_frame_eqn_types.h"
+#include "per_frame_eqn.h"
+
+#include "init_cond_types.h"
+#include "init_cond.h"
+
+#include "preset_types.h"
+
+#include "custom_wave_types.h"
+#include "custom_wave.h"
+
+#include "init_cond_types.h"
+#include "init_cond.h"
+
+#include "engine_vars.h"
+#define MAX_SAMPLE_SIZE 4096
+
+extern int mesh_i;
+
+custom_wave_t * interface_wave = NULL;
+int interface_id = 0;
+extern preset_t * active_preset;
+inline void eval_custom_wave_init_conds(custom_wave_t * custom_wave);
+void load_unspec_init_cond(param_t * param);
+void destroy_per_point_eqn_tree(splaytree_t * tree);
+void destroy_param_db_tree(splaytree_t * tree);
+void destroy_per_frame_eqn_tree(splaytree_t * tree);
+void destroy_per_frame_init_eqn_tree(splaytree_t * tree);
+void destroy_init_cond_tree(splaytree_t * tree);
+inline void evalPerPointEqn(per_point_eqn_t * per_point_eqn);
+
+custom_wave_t * new_custom_wave(int id) {
+
+  custom_wave_t * custom_wave;
+  param_t * param;
+  
+  if ((custom_wave = (custom_wave_t*)malloc(sizeof(custom_wave_t))) == NULL)
+    return NULL;
+
+  custom_wave->id = id;
+  custom_wave->per_frame_count = 0;
+
+  custom_wave->samples = 512;
+  custom_wave->bSpectrum = 0;
+  custom_wave->enabled = 1;
+  custom_wave->sep = 1;
+  custom_wave->smoothing = 0.0;
+  custom_wave->bUseDots = 0;
+  custom_wave->bAdditive = 0;
+  custom_wave->r = custom_wave->g = custom_wave->b = custom_wave->a = 0.0;
+  custom_wave->scaling = 1.0;
+  custom_wave->per_frame_eqn_string_index = 0;
+  custom_wave->per_frame_init_eqn_string_index = 0;
+  custom_wave->per_point_eqn_string_index = 0;
+
+  custom_wave->r_mesh = malloc(MAX_SAMPLE_SIZE*sizeof(double));
+  custom_wave->g_mesh = malloc(MAX_SAMPLE_SIZE*sizeof(double));
+  custom_wave->b_mesh = malloc(MAX_SAMPLE_SIZE*sizeof(double));
+  custom_wave->a_mesh = malloc(MAX_SAMPLE_SIZE*sizeof(double));
+  custom_wave->x_mesh = malloc(MAX_SAMPLE_SIZE*sizeof(double));
+  custom_wave->y_mesh = malloc(MAX_SAMPLE_SIZE*sizeof(double));
+  custom_wave->value1 = malloc(MAX_SAMPLE_SIZE*sizeof(double));
+  custom_wave->value2 = malloc(MAX_SAMPLE_SIZE*sizeof(double));
+  custom_wave->sample_mesh = malloc(MAX_SAMPLE_SIZE*sizeof(double));
+
+  /* Initialize tree data structures */
+  
+  if ((custom_wave->param_tree = 
+       create_splaytree(compare_string, copy_string, free_string)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((custom_wave->per_point_eqn_tree = 
+       create_splaytree(compare_int, copy_int, free_int)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((custom_wave->per_frame_eqn_tree = 
+       create_splaytree(compare_int, copy_int, free_int)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((custom_wave->init_cond_tree = 
+       create_splaytree(compare_string, copy_string, free_string)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+  
+  if ((custom_wave->per_frame_init_eqn_tree = 
+       create_splaytree(compare_string, copy_string, free_string)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  
+  /* Start: Load custom wave parameters */
+
+  if ((param = new_param_double("r", P_FLAG_DONT_FREE_MATRIX | P_FLAG_PER_POINT, &custom_wave->r, custom_wave->r_mesh, 1.0, 0.0, .5)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+  if ((param = new_param_double("g", P_FLAG_DONT_FREE_MATRIX | P_FLAG_PER_POINT, &custom_wave->g,  custom_wave->g_mesh, 1.0, 0.0, .5)) == NULL){
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_double("b", P_FLAG_DONT_FREE_MATRIX | P_FLAG_PER_POINT, &custom_wave->b,  custom_wave->b_mesh, 1.0, 0.0, .5)) == NULL){
+    free_custom_wave(custom_wave);
+    return NULL;                                      
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_double("a", P_FLAG_DONT_FREE_MATRIX | P_FLAG_PER_POINT, &custom_wave->a,  custom_wave->a_mesh, 1.0, 0.0, .5)) == NULL){
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+  
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_double("x", P_FLAG_DONT_FREE_MATRIX | P_FLAG_PER_POINT, &custom_wave->x,  custom_wave->x_mesh, 1.0, 0.0, .5)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_double("y", P_FLAG_DONT_FREE_MATRIX | P_FLAG_PER_POINT, &custom_wave->y,  custom_wave->y_mesh, 1.0, 0.0, .5)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_bool("enabled", P_FLAG_NONE, &custom_wave->enabled, 1, 0, 0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_int("sep", P_FLAG_NONE, &custom_wave->sep, 100, -100, 0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_bool("bSpectrum", P_FLAG_NONE, &custom_wave->bSpectrum, 1, 0, 0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_bool("bDrawThick", P_FLAG_NONE, &custom_wave->bDrawThick, 1, 0, 0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_bool("bUseDots", P_FLAG_NONE, &custom_wave->bUseDots, 1, 0, 0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+  if ((param = new_param_bool("bAdditive", P_FLAG_NONE, &custom_wave->bAdditive, 1, 0, 0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_int("samples", P_FLAG_NONE, &custom_wave->samples, 2048, 1, 512)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_double("sample", P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX | P_FLAG_ALWAYS_MATRIX | P_FLAG_PER_POINT,
+                               &custom_wave->sample, custom_wave->sample_mesh, 1.0, 0.0, 0.0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+ if (insert_param(param, custom_wave->param_tree) < 0) {
+    printf("failed to insert sample\n");
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_double("value1", P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX | P_FLAG_ALWAYS_MATRIX | P_FLAG_PER_POINT, &custom_wave->v1, custom_wave->value1, 1.0, -1.0, 0.0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_double("value2", P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX | P_FLAG_ALWAYS_MATRIX | P_FLAG_PER_POINT, &custom_wave->v2, custom_wave->value2, 1.0, -1.0, 0.0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_double("smoothing", P_FLAG_NONE, &custom_wave->smoothing, NULL, 1.0, 0.0, 0.0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_double("scaling", P_FLAG_NONE, &custom_wave->scaling, NULL, MAX_DOUBLE_SIZE, 0.0, 1.0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+  if ((param = new_param_double("t1", P_FLAG_PER_POINT | P_FLAG_TVAR, &custom_wave->t1, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_double("t2",  P_FLAG_PER_POINT |P_FLAG_TVAR, &custom_wave->t2, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_double("t3",  P_FLAG_PER_POINT |P_FLAG_TVAR, &custom_wave->t3, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+  if ((param = new_param_double("t4",  P_FLAG_PER_POINT |P_FLAG_TVAR, &custom_wave->t4, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+  if ((param = new_param_double("t5", P_FLAG_TVAR, &custom_wave->t5, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+  if ((param = new_param_double("t6", P_FLAG_TVAR | P_FLAG_PER_POINT, &custom_wave->t6, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+  if ((param = new_param_double("t7", P_FLAG_TVAR | P_FLAG_PER_POINT, &custom_wave->t7, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if ((param = new_param_double("t8", P_FLAG_TVAR | P_FLAG_PER_POINT, &custom_wave->t8, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+
+  if (insert_param(param, custom_wave->param_tree) < 0) {
+    free_custom_wave(custom_wave);
+    return NULL;
+  }
+  
+  /* End of parameter loading. Note that the read only parameters associated
+     with custom waves (ie, sample) are global variables, and not specific to 
+     the custom wave datastructure. */
+
+
+  return custom_wave;
+
+}
+
+void destroy_per_frame_init_eqn_tree(splaytree_t * tree) {
+
+  if (!tree)
+    return;
+
+  splay_traverse(free_init_cond, tree);
+  destroy_splaytree(tree);
+
+}
+
+
+void destroy_per_point_eqn_tree(splaytree_t * tree) {
+
+  if (!tree)
+    return;
+
+  splay_traverse(free_per_point_eqn, tree);
+  destroy_splaytree(tree);
+
+}
+
+void destroy_init_cond_tree(splaytree_t * tree) {
+
+  if (!tree)
+    return;
+
+  splay_traverse(free_init_cond, tree);
+  destroy_splaytree(tree);
+
+}
+
+void destroy_per_frame_eqn_tree(splaytree_t * tree) {
+
+
+  if (!tree)
+    return;
+
+  splay_traverse(free_per_frame_eqn, tree);
+  destroy_splaytree(tree);
+
+}
+
+
+void destroy_param_db_tree(splaytree_t * tree) {
+
+  if (!tree)
+    return;
+
+  splay_traverse(free_param, tree);
+  destroy_splaytree(tree);
+
+}
+
+/* Frees a custom wave form object */
+void free_custom_wave(custom_wave_t * custom_wave) {
+
+  if (custom_wave == NULL)
+    return;
+
+  if (custom_wave->param_tree == NULL)
+    return;
+
+  destroy_per_point_eqn_tree(custom_wave->per_point_eqn_tree);
+  destroy_per_frame_eqn_tree(custom_wave->per_frame_eqn_tree);
+  destroy_init_cond_tree(custom_wave->init_cond_tree);
+  destroy_param_db_tree(custom_wave->param_tree);
+  destroy_per_frame_init_eqn_tree(custom_wave->per_frame_init_eqn_tree);
+
+  free(custom_wave->r_mesh);
+  free(custom_wave->g_mesh);
+  free(custom_wave->b_mesh);
+  free(custom_wave->a_mesh);
+  free(custom_wave->x_mesh);
+  free(custom_wave->y_mesh);
+  free(custom_wave->value1);
+  free(custom_wave->value2);
+  free(custom_wave->sample_mesh);
+
+  free(custom_wave);
+
+  return;
+
+}
+
+
+
+int add_per_point_eqn(char * name, gen_expr_t * gen_expr, custom_wave_t * custom_wave) {
+
+  per_point_eqn_t * per_point_eqn;
+  int index;
+  param_t * param = NULL;
+
+  /* Argument checks */
+  if (custom_wave == NULL)
+         return FAILURE;
+  if (gen_expr == NULL)
+         return FAILURE;
+  if (name == NULL)
+         return FAILURE;
+  
+ if (CUSTOM_WAVE_DEBUG) printf("add_per_point_eqn: per pixel equation (name = \"%s\")\n", name);
+
+ /* Search for the parameter so we know what matrix the per pixel equation is referencing */
+
+ if ((param = find_param_db(name, custom_wave->param_tree, TRUE)) == NULL) {
+   if (CUSTOM_WAVE_DEBUG) printf("add_per_point_eqn: failed to allocate a new parameter!\n");
+   return FAILURE;
+ }      
+
+ /* Find most largest index in the splaytree */
+ if ((per_point_eqn = splay_find_max(custom_wave->per_point_eqn_tree)) == NULL)
+   index = 0;
+ else
+   index = per_point_eqn->index+1;
+
+ /* Create the per pixel equation given the index, parameter, and general expression */
+ if ((per_point_eqn = new_per_point_eqn(index, param, gen_expr)) == NULL)
+        return FAILURE;
+ if (CUSTOM_WAVE_DEBUG) 
+   printf("add_per_point_eqn: created new equation (index = %d) (name = \"%s\")\n", per_point_eqn->index, per_point_eqn->param->name);
+ /* Insert the per pixel equation into the preset per pixel database */
+ if (splay_insert(per_point_eqn, &per_point_eqn->index, custom_wave->per_point_eqn_tree) < 0) {
+       free_per_point_eqn(per_point_eqn);
+       return FAILURE;  
+ }
+        
+ /* Done */ 
+ return SUCCESS;
+}
+
+per_point_eqn_t * new_per_point_eqn(int index, param_t * param, gen_expr_t * gen_expr) {
+
+       per_point_eqn_t * per_point_eqn;
+       
+       if (param == NULL)
+               return NULL;
+       if (gen_expr == NULL)
+               return NULL;
+
+       if ((per_point_eqn = (per_point_eqn_t*)malloc(sizeof(per_point_eqn_t))) == NULL)
+               return NULL;
+
+      
+       per_point_eqn->index = index;
+       per_point_eqn->gen_expr = gen_expr;
+       per_point_eqn->param = param;
+       return per_point_eqn;   
+}
+
+
+void free_per_point_eqn(per_point_eqn_t * per_point_eqn) {
+
+       if (per_point_eqn == NULL)
+               return;
+       
+       free_gen_expr(per_point_eqn->gen_expr);
+       
+       free(per_point_eqn);
+       
+       return;
+}
+
+custom_wave_t * find_custom_wave(int id, preset_t * preset, int create_flag) {
+
+  custom_wave_t * custom_wave = NULL;
+
+  if (preset == NULL)
+    return NULL;
+  
+  if ((custom_wave = splay_find(&id, preset->custom_wave_tree)) == NULL) {
+
+    if (CUSTOM_WAVE_DEBUG) { printf("find_custom_wave: creating custom wave (id = %d)...", id);fflush(stdout);}
+
+    if (create_flag == FALSE) {
+      if (CUSTOM_WAVE_DEBUG) printf("you specified not to (create flag = false), returning null\n");
+       return NULL;
+    }
+
+    if ((custom_wave = new_custom_wave(id)) == NULL) {
+      if (CUSTOM_WAVE_DEBUG) printf("failed...out of memory?\n");
+      return NULL;
+    }
+
+    if  (CUSTOM_WAVE_DEBUG) {printf("success.Inserting..."); fflush(stdout);}
+
+   if (splay_insert(custom_wave, &custom_wave->id, preset->custom_wave_tree) < 0) {
+     if (CUSTOM_WAVE_DEBUG) printf("failed!\n");
+     free_custom_wave(custom_wave);
+     return NULL;
+    }
+   if (CUSTOM_WAVE_DEBUG) printf("done.\n");
+  }
+  return custom_wave;
+}
+
+inline void evalCustomWaveInitConditions() {
+  splay_traverse(eval_custom_wave_init_conds, active_preset->custom_wave_tree);
+}
+
+inline void eval_custom_wave_init_conds(custom_wave_t * custom_wave) {
+  splay_traverse(eval_init_cond, custom_wave->init_cond_tree);
+  splay_traverse(eval_init_cond, custom_wave->per_frame_init_eqn_tree);
+}
+
+/* Interface function. Makes another custom wave the current
+   concern for per frame / point equations */
+inline custom_wave_t * nextCustomWave() {
+
+  if ((interface_wave = splay_find(&interface_id, active_preset->custom_wave_tree)) == NULL) {
+    interface_id = 0;
+    return NULL;
+  }
+
+  interface_id++;
+
+  /* Evaluate all per frame equations associated with this wave */
+  splay_traverse(eval_per_frame_eqn, interface_wave->per_frame_eqn_tree);
+  return interface_wave;
+}
+
+
+inline void evalPerPointEqns() { 
+
+  int x;
+
+  for (x = 0; x < interface_wave->samples; x++)
+    interface_wave->r_mesh[x] = interface_wave->r;
+  for (x = 0; x < interface_wave->samples; x++)
+    interface_wave->g_mesh[x] = interface_wave->g;
+  for (x = 0; x < interface_wave->samples; x++)
+    interface_wave->b_mesh[x] = interface_wave->b;
+  for (x = 0; x < interface_wave->samples; x++)
+    interface_wave->a_mesh[x] = interface_wave->a;
+  for (x = 0; x < interface_wave->samples; x++)
+    interface_wave->x_mesh[x] = interface_wave->x;
+  for (x = 0; x < interface_wave->samples; x++)
+    interface_wave->y_mesh[x] = interface_wave->y;
+
+  /* Evaluate per pixel equations */
+  splay_traverse(evalPerPointEqn, interface_wave->per_point_eqn_tree);
+
+  /* Reset index */
+  mesh_i = -1;
+}
+
+/* Evaluates a per point equation for the current custom wave given by interface_wave ptr */
+inline void evalPerPointEqn(per_point_eqn_t * per_point_eqn) {
+  
+  
+  int samples, size;
+  double * param_matrix;
+  gen_expr_t * eqn_ptr;
+
+  samples = interface_wave->samples;
+  eqn_ptr = per_point_eqn->gen_expr;
+  if (per_point_eqn->param->matrix == NULL) {
+    if ((param_matrix = per_point_eqn->param->matrix = malloc(size = samples*sizeof(double))) == NULL)
+      return;
+    memset(param_matrix, 0, size);
+  }
+  else 
+    param_matrix = (double*)per_point_eqn->param->matrix;
+  
+  for (mesh_i = 0; mesh_i < samples; mesh_i++) {    
+      param_matrix[mesh_i] = eval_gen_expr(eqn_ptr);
+  }
+  
+  /* Now that this parameter has been referenced with a per
+     point equation, we let the evaluator know by setting
+     this flag */
+  per_point_eqn->param->matrix_flag = 1; 
+
+}
+
+
+void load_unspecified_init_conds(custom_wave_t * custom_wave) {
+
+  interface_wave = custom_wave;
+  splay_traverse(load_unspec_init_cond, interface_wave->param_tree);
+  interface_wave = NULL;
+}
+
+void load_unspec_init_cond(param_t * param) {
+
+  init_cond_t * init_cond;
+  value_t init_val;
+
+  /* Don't count these parameters as initial conditions */
+  if (param->flags & P_FLAG_READONLY)
+    return;
+  if (param->flags & P_FLAG_QVAR)
+    return;
+  if (param->flags & P_FLAG_TVAR)
+    return;
+  if (param->flags & P_FLAG_USERDEF)
+    return;
+
+  /* If initial condition was not defined by the preset file, force a default one
+     with the following code */
+  if ((init_cond = splay_find(param->name, interface_wave->init_cond_tree)) == NULL) {
+    
+    /* Make sure initial condition does not exist in the set of per frame initial equations */
+    if ((init_cond = splay_find(param->name, interface_wave->per_frame_init_eqn_tree)) != NULL)
+      return;
+    
+    if (param->type == P_TYPE_BOOL)
+      init_val.bool_val = 0;
+    
+    else if (param->type == P_TYPE_INT)
+      init_val.int_val = *(int*)param->engine_val;
+
+    else if (param->type == P_TYPE_DOUBLE)
+      init_val.double_val = *(double*)param->engine_val;
+
+    //printf("%s\n", param->name);
+    /* Create new initial condition */
+    if ((init_cond = new_init_cond(param, init_val)) == NULL)
+      return;
+    
+    /* Insert the initial condition into this presets tree */
+    if (splay_insert(init_cond, init_cond->param->name, interface_wave->init_cond_tree) < 0) {
+      free_init_cond(init_cond);
+      return;
+    }
+    
+  }
+}
diff --git a/modules/visualization/galaktos/custom_wave.h b/modules/visualization/galaktos/custom_wave.h
new file mode 100644 (file)
index 0000000..af330bf
--- /dev/null
@@ -0,0 +1,22 @@
+#ifndef CUSTOM_WAVE_H
+#define CUSTOM_WAVE_H
+#define CUSTOM_WAVE_DEBUG 0
+#include "expr_types.h"
+#include "custom_wave_types.h"
+#include "preset_types.h"
+
+void free_custom_wave(custom_wave_t * custom_wave);
+custom_wave_t * new_custom_wave(int id);
+
+void free_per_point_eqn(per_point_eqn_t * per_point_eqn);
+per_point_eqn_t * new_per_point_eqn(int index, param_t * param,gen_expr_t * gen_expr);
+void reset_per_point_eqn_array(custom_wave_t * custom_wave);
+custom_wave_t * find_custom_wave(int id, preset_t * preset, int create_flag);
+
+int add_per_point_eqn(char * name, gen_expr_t * gen_expr, custom_wave_t * custom_wave);
+inline void evalCustomWaveInitConditions();
+inline void evalPerPointEqns();
+inline custom_wave_t * nextCustomWave();
+void load_unspecified_init_conds(custom_wave_t * custom_wave);
+
+#endif
diff --git a/modules/visualization/galaktos/custom_wave_types.h b/modules/visualization/galaktos/custom_wave_types.h
new file mode 100644 (file)
index 0000000..3148181
--- /dev/null
@@ -0,0 +1,92 @@
+#ifndef CUSTOM_WAVE_TYPES_H
+#define CUSTOM_WAVE_TYPES_H
+#include "common.h"
+#include "splaytree_types.h"
+#include "expr_types.h"
+
+#define X_POINT_OP 0
+#define Y_POINT_OP 1
+#define R_POINT_OP 2
+#define G_POINT_OP 3
+#define B_POINT_OP 4
+#define A_POINT_OP 5
+#define NUM_POINT_OPS 6
+
+typedef struct PER_POINT_EQN_T {
+  int index;
+  param_t * param;
+  gen_expr_t * gen_expr;       
+} per_point_eqn_t;
+
+typedef struct CUSTOM_WAVE_T {
+
+  /* Numerical id */
+  int id;
+  int per_frame_count;
+
+  /* Parameter tree associated with this custom wave */
+  splaytree_t * param_tree;
+
+
+  /* Engine variables */
+
+  double x; /* x position for per point equations */
+  double y; /* y position for per point equations */
+  double r; /* red color value */
+  double g; /* green color value */
+  double b; /* blue color value */
+  double a; /* alpha color value */
+  double * x_mesh;
+  double * y_mesh;
+  double * r_mesh;
+  double * b_mesh;
+  double * g_mesh;
+  double * a_mesh;
+  double * value1;
+  double * value2;
+  double * sample_mesh;
+
+  int enabled; /* if nonzero then wave is visible, hidden otherwise */
+  int samples; /* number of samples associated with this wave form. Usually powers of 2 */
+  double sample;
+  int bSpectrum; /* spectrum data or pcm data */
+  int bUseDots; /* draw wave as dots or lines */
+  int bDrawThick; /* draw thicker lines */
+  int bAdditive; /* add color values together */
+
+  double scaling; /* scale factor of waveform */
+  double smoothing; /* smooth factor of waveform */
+  int sep;  /* no idea what this is yet... */
+
+  /* stupid t variables */
+  double t1;
+  double t2;
+  double t3;
+  double t4;
+  double t5;
+  double t6;
+  double t7;
+  double t8;
+  double v1,v2;
+  /* Data structure to hold per frame and per point equations */
+  splaytree_t * init_cond_tree;
+  splaytree_t * per_frame_eqn_tree;
+  splaytree_t * per_point_eqn_tree;
+  splaytree_t * per_frame_init_eqn_tree;
+
+  /* Denotes the index of the last character for each string buffer */
+  int per_point_eqn_string_index;
+  int per_frame_eqn_string_index;
+  int per_frame_init_eqn_string_index;
+
+  /* String buffers for per point and per frame equations */
+  char per_point_eqn_string_buffer[STRING_BUFFER_SIZE];
+  char per_frame_eqn_string_buffer[STRING_BUFFER_SIZE];
+  char per_frame_init_eqn_string_buffer[STRING_BUFFER_SIZE];
+  /* Per point equation array */
+  gen_expr_t * per_point_eqn_array[NUM_POINT_OPS];
+  
+} custom_wave_t;
+
+
+#endif
diff --git a/modules/visualization/galaktos/engine_vars.c b/modules/visualization/galaktos/engine_vars.c
new file mode 100644 (file)
index 0000000..9ad71a5
--- /dev/null
@@ -0,0 +1,166 @@
+/*****************************************************************************
+ * engine_vars.c:
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id$
+ *
+ * Authors: Cyril Deguet <asmax@videolan.org>
+ *          code from projectM http://xmms-projectm.sourceforge.net
+ *
+ * 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, USA.
+ *****************************************************************************/
+
+
+
+/* Include engine_vars.h to use these variables */
+ char preset_name[256];
+/* PER FRAME CONSTANTS BEGIN */
+ double zoom=1.0;
+ double zoomexp= 1.0;
+ double rot= 0.0;
+ double warp= 0.0;
+
+ double sx= 1.0;
+ double sy= 1.0;
+ double dx= 0.0;
+ double dy= 0.0;
+ double cx= 0.5;
+ double cy= 0.5;
+
+  int gx = 32;
+  int gy = 24;
+
+ double decay=.98;
+
+ double wave_r= 1.0;
+ double wave_g= 0.2;
+ double wave_b= 0.0;
+ double wave_x= 0.5;
+ double wave_y= 0.5;
+ double wave_mystery= 0.0;
+
+ double ob_size= 0.0;
+ double ob_r= 0.0;
+ double ob_g= 0.0;
+ double ob_b= 0.0;
+ double ob_a= 0.0;
+
+ double ib_size = 0.0;
+ double ib_r = 0.0;
+ double ib_g = 0.0;
+ double ib_b = 0.0;
+ double ib_a = 0.0;
+
+ double mv_a = 0.0;
+ double mv_r = 0.0;
+ double mv_g = 0.0;
+ double mv_b = 0.0;
+ double mv_l = 1.0;
+ double mv_x = 16.0;
+ double mv_y = 12.0;
+ double mv_dy = 0.02;
+ double mv_dx = 0.02;
+  
+ int meshx = 0;
+ int meshy = 0;
+ double Time = 0;
+ double treb = 0;
+ double mid = 0;
+ double bass = 0;
+ double treb_att = 0;
+ double mid_att = 0;
+ double bass_att = 0;
+ double progress = 0;
+ int frame = 0;
+ int fps = 30;
+//double bass_thresh = 0;
+
+/* PER_FRAME CONSTANTS END */
+ double fRating = 0;
+ double fGammaAdj = 1.0;
+ double fVideoEchoZoom = 1.0;
+ double fVideoEchoAlpha = 0;
+ double nVideoEchoOrientation = 0;
+ int nWaveMode = 7;
+ int bAdditiveWaves = 0;
+ int bWaveDots = 0;
+ int bWaveThick = 0;
+ int bModWaveAlphaByVolume = 0;
+ int bMaximizeWaveColor = 0;
+ int bTexWrap = 0;
+ int bDarkenCenter = 0;
+ int bRedBlueStereo = 0;
+ int bBrighten = 0;
+ int bDarken = 0;
+ int bSolarize = 0;
+int bInvert = 0;
+int bMotionVectorsOn = 1;
+ double fWaveAlpha =1.0;
+ double fWaveScale = 1.0;
+ double fWaveSmoothing = 0;
+ double fWaveParam = 0;
+ double fModWaveAlphaStart = 0;
+ double fModWaveAlphaEnd = 0;
+ double fWarpAnimSpeed = 0;
+ double fWarpScale = 0;
+ double fShader = 0;
+
+
+/* PER_PIXEL CONSTANTS BEGIN */
+double x_per_pixel = 0;
+double y_per_pixel = 0;
+double rad_per_pixel = 0;
+double ang_per_pixel = 0;
+
+/* PER_PIXEL CONSTANT END */
+
+
+/* Q AND T VARIABLES START */
+
+double q1 = 0;
+double q2 = 0;
+double q3 = 0;
+double q4 = 0;
+double q5 = 0;
+double q6 = 0;
+double q7 = 0;
+double q8 = 0;
+
+
+/* Q AND T VARIABLES END */
+
+//per pixel meshes
+ double **zoom_mesh;
+ double **zoomexp_mesh;
+ double **rot_mesh;
+
+ double **sx_mesh;
+ double **sy_mesh;
+ double **dx_mesh;
+ double **dy_mesh;
+ double **cx_mesh;
+ double **cy_mesh;
+
+ double **x_mesh;
+ double **y_mesh;
+ double **rad_mesh;
+ double **theta_mesh;
+
+//custom wave per point meshes
+
diff --git a/modules/visualization/galaktos/engine_vars.h b/modules/visualization/galaktos/engine_vars.h
new file mode 100644 (file)
index 0000000..3854d3d
--- /dev/null
@@ -0,0 +1,142 @@
+/* Temporay file until these variables are all externed */
+#ifndef ENGINE_VARS_H
+#define ENGINE_VARS_H
+
+extern char preset_name[256];
+
+/* PER FRAME CONSTANTS BEGIN */
+extern double zoom;
+extern double zoomexp;
+extern double rot;
+extern double warp;
+
+extern double sx;
+extern double sy;
+extern double dx;
+extern double dy;
+extern double cx;
+extern double cy;
+
+extern int gy;
+extern int gx;
+
+extern double decay;
+
+extern double wave_r;
+extern double wave_g;
+extern double wave_b;
+extern double wave_x;
+extern double wave_y;
+extern double wave_mystery;
+
+extern double ob_size;
+extern double ob_r;
+extern double ob_g;
+extern double ob_b;
+extern double ob_a;
+
+extern double ib_size;
+extern double ib_r;
+extern double ib_g;
+extern double ib_b;
+extern double ib_a;
+
+extern int meshx;
+extern int meshy;
+
+extern double mv_a ;
+extern double mv_r ;
+extern double mv_g ;
+extern double mv_b ;
+extern double mv_l;
+extern double mv_x;
+extern double mv_y;
+extern double mv_dy;
+extern double mv_dx;
+
+extern double Time;
+extern double treb ;
+extern double mid ;
+extern double bass ;
+extern double treb_att ;
+extern double mid_att ;
+extern double bass_att ;
+extern double progress ;
+extern int frame ;
+
+/* PER_FRAME CONSTANTS END */
+
+/* PER_PIXEL CONSTANTS BEGIN */
+
+extern double x_per_pixel;
+extern double y_per_pixel;
+extern double rad_per_pixel;
+extern double ang_per_pixel;
+
+/* PER_PIXEL CONSTANT END */
+
+
+extern double fRating;
+extern double fGammaAdj;
+extern double fVideoEchoZoom;
+extern double fVideoEchoAlpha;
+
+extern int nVideoEchoOrientation;
+extern int nWaveMode;
+extern int bAdditiveWaves;
+extern int bWaveDots;
+extern int bWaveThick;
+extern int bModWaveAlphaByVolume;
+extern int bMaximizeWaveColor;
+extern int bTexWrap;
+extern int bDarkenCenter;
+extern int bRedBlueStereo;
+extern int bBrighten;
+extern int bDarken;
+extern int bSolarize;
+extern int bInvert;
+extern int bMotionVectorsOn;
+extern int fps; 
+
+extern double fWaveAlpha ;
+extern double fWaveScale;
+extern double fWaveSmoothing;
+extern double fWaveParam;
+extern double fModWaveAlphaStart;
+extern double fModWaveAlphaEnd;
+extern double fWarpAnimSpeed;
+extern double fWarpScale;
+extern double fShader;
+
+
+/* Q VARIABLES START */
+
+extern double q1;
+extern double q2;
+extern double q3;
+extern double q4;
+extern double q5;
+extern double q6;
+extern double q7;
+extern double q8;
+
+
+/* Q VARIABLES END */
+
+extern double **zoom_mesh;
+extern double **zoomexp_mesh;
+extern double **rot_mesh;
+
+extern double **sx_mesh;
+extern double **sy_mesh;
+extern double **dx_mesh;
+extern double **dy_mesh;
+extern double **cx_mesh;
+extern double **cy_mesh;
+
+extern double **x_mesh;
+extern double **y_mesh;
+extern double **rad_mesh;
+extern double **theta_mesh;
+
+#endif
diff --git a/modules/visualization/galaktos/eval.c b/modules/visualization/galaktos/eval.c
new file mode 100644 (file)
index 0000000..608bae6
--- /dev/null
@@ -0,0 +1,785 @@
+/*****************************************************************************
+ * eval.c:
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id$
+ *
+ * Authors: Cyril Deguet <asmax@videolan.org>
+ *          code from projectM http://xmms-projectm.sourceforge.net
+ *
+ * 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, USA.
+ *****************************************************************************/
+
+
+
+/* Evaluation Code */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "common.h"
+#include "fatal.h"
+
+#include "param_types.h"
+#include "func_types.h"
+#include "expr_types.h"
+#include "eval.h"
+#include "engine_vars.h"
+#include "builtin_funcs.h"
+#define EVAL_ERROR -1
+
+/* All infix operators (except '=') are prototyped here */
+infix_op_t * infix_add, * infix_minus, * infix_div, * infix_mult,
+  * infix_or, * infix_and, * infix_mod, * infix_negative, * infix_positive;
+int mesh_i=-1, mesh_j=-1;
+
+static inline double eval_tree_expr(tree_expr_t * tree_expr);
+static inline double eval_prefun_expr(prefun_expr_t * prefun_expr);
+static inline double eval_val_expr(val_expr_t * val_expr);
+
+
+inline double eval_gen_expr(gen_expr_t * gen_expr) {
+  double l;
+
+  if (gen_expr == NULL) 
+       return 0;
+       
+  switch(gen_expr->type) {
+  case VAL_T:  
+    return eval_val_expr(gen_expr->item);
+  case PREFUN_T:
+    l = eval_prefun_expr(gen_expr->item);
+    //if (EVAL_DEBUG) printf("eval_gen_expr: prefix function return value: %f\n", l);
+    return l;          
+  case TREE_T:
+    return eval_tree_expr(gen_expr->item);
+  default:
+    #ifdef EVAL_DEBUG
+    printf("eval_gen_expr: general expression matched no cases!\n");
+    #endif
+    return EVAL_ERROR;
+  }  
+       
+}
+
+/* Evaluates functions in prefix form */
+static inline double eval_prefun_expr(prefun_expr_t * prefun_expr) {
+       int i;
+       
+       
+       /* This is slightly less than safe, since
+          who knows if the passed argument is valid. For 
+          speed purposes we'll go with this */
+       double arg_list[prefun_expr->num_args];
+       
+       #ifdef EVAL_DEBUG 
+               printf("fn[");
+               fflush(stdout);
+       #endif
+       /* Evaluate each argument before calling the function itself */
+       for (i = 0; i < prefun_expr->num_args; i++) {
+               arg_list[i] = eval_gen_expr(prefun_expr->expr_list[i]);
+               #ifdef EVAL_DEBUG 
+                       if (i < (prefun_expr->num_args - 1))
+                               printf(", ");
+                       fflush(stdout);
+               #endif
+       }
+       
+       #ifdef EVAL_DEBUG 
+               printf("]");
+               fflush(stdout);
+       #endif
+       
+       /* Now we call the function, passing a list of  
+          doubles as its argument */
+     
+
+     
+       return (prefun_expr->func_ptr)(arg_list);       
+}      
+
+/* Evaluates a value expression */
+static inline double eval_val_expr(val_expr_t * val_expr) {
+
+  /* Shouldn't happen */
+  if (val_expr == NULL)
+    return EVAL_ERROR;
+
+  /* Value is a constant, return the double value */
+  if (val_expr->type == CONSTANT_TERM_T) {
+    #ifdef EVAL_DEBUG 
+               printf("%.4f", val_expr->term.constant);
+               fflush(stdout);
+    #endif
+    return (val_expr->term.constant);
+  }
+
+  /* Value is variable, dereference it */
+  if (val_expr->type == PARAM_TERM_T) {
+       switch (val_expr->term.param->type) {
+               
+       case P_TYPE_BOOL:
+               #ifdef EVAL_DEBUG 
+                       printf("(%s:%.4f)", val_expr->term.param->name, (double)(*((int*)(val_expr->term.param->engine_val))));
+                       fflush(stdout);
+               #endif
+              
+                 
+               return (double)(*((int*)(val_expr->term.param->engine_val)));
+       case P_TYPE_INT:
+               #ifdef EVAL_DEBUG 
+                       printf("(%s:%.4f)", val_expr->term.param->name, (double)(*((int*)(val_expr->term.param->engine_val))));
+                       fflush(stdout);
+               #endif
+
+            
+               return (double)(*((int*)(val_expr->term.param->engine_val)));
+       case P_TYPE_DOUBLE:             
+               #ifdef EVAL_DEBUG 
+                       printf("(%s:%.4f)", val_expr->term.param->name, (*((double*)val_expr->term.param->engine_val)));
+                       fflush(stdout);
+               #endif
+                       
+               if (val_expr->term.param->matrix_flag | (val_expr->term.param->flags & P_FLAG_ALWAYS_MATRIX)) {
+                 if (mesh_j >= 0) {
+                   return (((double**)val_expr->term.param->matrix)[mesh_i][mesh_j]);
+                 }
+                 else {
+                   return (((double*)val_expr->term.param->matrix)[mesh_i]);
+                 }
+               }
+               return *((double*)(val_expr->term.param->engine_val));
+       default:
+         return ERROR; 
+    }
+  }
+  /* Unknown type, return failure */
+  return FAILURE;
+}
+
+/* Evaluates an expression tree */
+static inline double eval_tree_expr(tree_expr_t * tree_expr) {
+               
+       double left_arg, right_arg;     
+       infix_op_t * infix_op;
+       
+       /* Shouldn't happen */
+       if (tree_expr == NULL)
+         return EVAL_ERROR;
+
+       /* A leaf node, evaluate the general expression. If the expression is null as well, return zero */
+       if (tree_expr->infix_op == NULL) {
+               if (tree_expr->gen_expr == NULL)
+                       return 0;
+               else
+                       return eval_gen_expr(tree_expr->gen_expr);
+       }
+       
+       /* Otherwise, this node is an infix operator. Evaluate
+          accordingly */
+       
+       infix_op = (infix_op_t*)tree_expr->infix_op;    
+       #ifdef EVAL_DEBUG 
+               printf("(");
+               fflush(stdout);
+       #endif
+       
+       left_arg = eval_tree_expr(tree_expr->left);
+
+       #ifdef EVAL_DEBUG 
+               
+               switch (infix_op->type) {
+               case INFIX_ADD:
+                       printf("+");
+                       break;          
+               case INFIX_MINUS:
+                       printf("-");
+                       break;
+               case INFIX_MULT:
+                       printf("*");
+                       break;
+               case INFIX_MOD:
+                       printf("%%");
+                       break;
+               case INFIX_OR:
+                       printf("|");
+                       break;
+               case INFIX_AND:
+                       printf("&");
+                       break;
+               case INFIX_DIV:
+                       printf("/");
+                       break;
+               default:
+                       printf("?");
+               }
+       
+       fflush(stdout); 
+       #endif
+       
+       right_arg = eval_tree_expr(tree_expr->right);
+       
+       #ifdef EVAL_DEBUG
+               printf(")");
+               fflush(stdout);
+       #endif
+       
+       switch (infix_op->type) {               
+       case INFIX_ADD:
+         return (left_arg + right_arg);                
+       case INFIX_MINUS:
+               return (left_arg - right_arg);
+       case INFIX_MULT:
+               return (left_arg * right_arg);
+       case INFIX_MOD:
+         if ((int)right_arg == 0) {
+           #ifdef EVAL_DEBUG 
+           printf("eval_tree_expr: modulo zero!\n");
+           #endif
+           return DIV_BY_ZERO; 
+         }
+         return ((int)left_arg % (int)right_arg);
+       case INFIX_OR:
+               return ((int)left_arg | (int)right_arg);
+       case INFIX_AND:
+               return ((int)left_arg & (int)right_arg);
+       case INFIX_DIV:
+         if (right_arg == 0) {
+           #ifdef EVAL_DEBUG 
+           printf("eval_tree_expr: division by zero!\n");
+           #endif
+           return MAX_DOUBLE_SIZE;
+         }             
+         return (left_arg / right_arg);
+       default:
+          #ifdef EVAL_DEBUG 
+           printf("eval_tree_expr: unknown infix operator!\n");
+          #endif
+               return ERROR;
+       }
+       
+       return ERROR;
+}      
+
+/* Converts a double value to a general expression */
+gen_expr_t * const_to_expr(double val) {
+
+  gen_expr_t * gen_expr;
+  val_expr_t * val_expr;
+  term_t term;
+  
+  term.constant = val;
+    
+  if ((val_expr = new_val_expr(CONSTANT_TERM_T, term)) == NULL)
+    return NULL;
+
+  gen_expr = new_gen_expr(VAL_T, (void*)val_expr);
+
+  if (gen_expr == NULL) {
+       free_val_expr(val_expr);
+  }
+  
+  return gen_expr;
+}
+
+/* Converts a regular parameter to an expression */
+gen_expr_t * param_to_expr(param_t * param) {
+
+  gen_expr_t * gen_expr = NULL;
+  val_expr_t * val_expr = NULL;
+  term_t term;
+
+  if (param == NULL)
+    return NULL;
+  /* This code is still a work in progress. We need
+     to figure out if the initial condition is used for 
+     each per frame equation or not. I am guessing that
+     it isn't, and it is thusly implemented this way */
+  
+  /* Current guess of true behavior (08/01/03) note from carm
+     First try to use the per_pixel_expr (with cloning). 
+     If it is null however, use the engine variable instead. */
+  
+  /* 08/20/03 : Presets are now objects, as well as per pixel equations. This ends up
+     making the parser handle the case where parameters are essentially per pixel equation
+     substitutions */
+       
+  
+  term.param = param;
+  if ((val_expr = new_val_expr(PARAM_TERM_T, term)) == NULL)
+    return NULL;
+  
+  if ((gen_expr = new_gen_expr(VAL_T, (void*)val_expr)) == NULL) {
+    free_val_expr(val_expr);
+       return NULL;      
+  } 
+  return gen_expr;
+}
+
+/* Converts a prefix function to an expression */
+gen_expr_t * prefun_to_expr(double (*func_ptr)(), gen_expr_t ** expr_list, int num_args) {
+
+  gen_expr_t * gen_expr;
+  prefun_expr_t * prefun_expr;
+  
+
+  /* Malloc a new prefix function expression */
+  prefun_expr = (prefun_expr_t*)malloc(sizeof(prefun_expr_t));
+
+  if (prefun_expr == NULL)
+         return NULL;
+  
+  prefun_expr->num_args = num_args;
+  prefun_expr->func_ptr = func_ptr;
+  prefun_expr->expr_list = expr_list;
+
+  gen_expr = new_gen_expr(PREFUN_T, (void*)prefun_expr);
+
+  if (gen_expr == NULL)
+         free_prefun_expr(prefun_expr);
+  
+  return gen_expr;
+}
+
+/* Creates a new tree expression */
+tree_expr_t * new_tree_expr(infix_op_t * infix_op, gen_expr_t * gen_expr, tree_expr_t * left, tree_expr_t * right) {
+
+               tree_expr_t * tree_expr;
+               tree_expr = (tree_expr_t*)malloc(sizeof(tree_expr_t));
+       
+               if (tree_expr == NULL)
+                       return NULL;
+               tree_expr->infix_op = infix_op;
+               tree_expr->gen_expr = gen_expr;
+               tree_expr->left = left;
+               tree_expr->right = right;
+               return tree_expr;
+}
+
+
+/* Creates a new value expression */
+val_expr_t * new_val_expr(int type, term_t term) {
+
+  val_expr_t * val_expr;
+  val_expr = (val_expr_t*)malloc(sizeof(val_expr_t));
+
+  if (val_expr == NULL)
+    return NULL;
+
+  val_expr->type = type;
+  val_expr->term = term;
+
+  return val_expr;
+}
+
+/* Creates a new general expression */
+gen_expr_t * new_gen_expr(int type, void * item) {
+
+       gen_expr_t * gen_expr;
+
+       gen_expr = (gen_expr_t*)malloc(sizeof(gen_expr_t));
+       if (gen_expr == NULL)
+               return NULL;
+       gen_expr->type = type;
+       gen_expr->item = item;  
+
+       return gen_expr;
+}
+
+/* Frees a general expression */
+int free_gen_expr(gen_expr_t * gen_expr) {
+
+       if (gen_expr == NULL)
+               return SUCCESS;
+       
+       switch (gen_expr->type) {
+       case VAL_T:
+               free_val_expr(gen_expr->item);
+               break;
+       case PREFUN_T:
+               free_prefun_expr(gen_expr->item);
+               break;
+       case TREE_T:
+               free_tree_expr(gen_expr->item);
+               break;
+       default:
+               return FAILURE;
+       }       
+
+       free(gen_expr);
+       return SUCCESS;
+
+}
+
+
+/* Frees a function in prefix notation */
+int free_prefun_expr(prefun_expr_t * prefun_expr) {
+
+       int i;
+       if (prefun_expr == NULL)
+               return SUCCESS;
+       
+       /* Free every element in expression list */
+       for (i = 0 ; i < prefun_expr->num_args; i++) {
+               free_gen_expr(prefun_expr->expr_list[i]);
+       }
+
+       free(prefun_expr);
+       return SUCCESS;
+}
+
+/* Frees values of type VARIABLE and CONSTANT */
+int free_val_expr(val_expr_t * val_expr) {
+
+       if (val_expr == NULL)
+               return SUCCESS; 
+       
+       free(val_expr);
+       return SUCCESS;
+}
+
+/* Frees a tree expression */
+int free_tree_expr(tree_expr_t * tree_expr) {
+
+       if (tree_expr == NULL)
+               return SUCCESS;
+       
+       /* free left tree */
+       free_tree_expr(tree_expr->left);
+       
+       /* free general expression object */
+       free_gen_expr(tree_expr->gen_expr);
+       
+       /* Note that infix operators are always
+          stored in memory unless the program 
+          exits, so we don't remove them here */
+       
+       /* free right tree */
+       free_tree_expr(tree_expr->right);
+       
+       
+       /* finally, free the struct itself */
+       free(tree_expr);
+       return SUCCESS;
+}
+
+
+
+/* Initializes all infix operators */
+int init_infix_ops() {
+
+       infix_add = new_infix_op(INFIX_ADD, 4);
+       infix_minus = new_infix_op(INFIX_MINUS, 3);
+       infix_div = new_infix_op(INFIX_DIV, 2);
+       infix_or = new_infix_op(INFIX_OR, 5);
+       infix_and = new_infix_op(INFIX_AND,4);
+       infix_mod = new_infix_op(INFIX_MOD, 1);
+       infix_mult = new_infix_op(INFIX_MULT, 2);
+       
+       /* Prefix operators */
+       infix_positive = new_infix_op(INFIX_ADD, 0);
+       infix_negative = new_infix_op(INFIX_MINUS, 0);
+
+       return SUCCESS;
+}
+
+/* Destroys the infix operator list. This should
+   be done on program exit */
+int destroy_infix_ops()
+{
+
+  free(infix_add);
+  free(infix_minus);
+  free(infix_div);
+  free(infix_or);
+  free(infix_and);
+  free(infix_mod);
+  free(infix_mult);
+  free(infix_positive);
+  free(infix_negative);
+
+  return SUCCESS;
+}
+
+/* Initializes an infix operator */
+infix_op_t * new_infix_op(int type, int precedence) {
+
+       infix_op_t * infix_op;
+       
+       infix_op = (infix_op_t*)malloc(sizeof(infix_op_t));
+       
+       if (infix_op == NULL)
+               return NULL;
+       
+       infix_op->type = type;
+       infix_op->precedence = precedence;
+       
+       return infix_op;
+}
+
+
+
+
+/* Clones a general expression */
+gen_expr_t * clone_gen_expr(gen_expr_t * gen_expr) {
+
+  gen_expr_t * new_gen_expr;
+  val_expr_t * val_expr;
+  tree_expr_t * tree_expr;
+  prefun_expr_t * prefun_expr;
+
+  /* Null argument check */
+  if (gen_expr == NULL)
+    return NULL;
+
+  /* Out of memory */
+  if ((new_gen_expr = (gen_expr_t*)malloc(sizeof(gen_expr_t))) == NULL)
+    return NULL;
+
+  /* Case on the type of general expression */
+  switch (new_gen_expr->type = gen_expr->type) {
+
+  case VAL_T: /* val expression */
+    if ((val_expr = clone_val_expr((val_expr_t*)gen_expr->item)) == NULL) {
+      free(new_gen_expr);
+      return NULL;
+    }
+    new_gen_expr->item = (void*)val_expr;
+    break;
+    
+  case PREFUN_T: /* prefix function expression */
+    if ((prefun_expr = clone_prefun_expr((prefun_expr_t*)gen_expr->item)) == NULL) {
+      free(new_gen_expr);
+      return NULL;
+    }
+    new_gen_expr->item = (void*)prefun_expr;
+    break;
+    
+  case TREE_T:  /* tree expression */
+    if ((tree_expr = clone_tree_expr((tree_expr_t*)gen_expr->item)) == NULL) {
+      free(new_gen_expr);
+      return NULL;
+    }
+    new_gen_expr->item = (void*)tree_expr;
+    break;
+    
+  default: /* unknown type, ut oh.. */
+    free(new_gen_expr);
+    return NULL;
+  }
+  
+  return new_gen_expr; /* Return the new (cloned) general expression */
+}
+
+
+/* Clones a tree expression */
+tree_expr_t * clone_tree_expr(tree_expr_t * tree_expr) {
+
+  tree_expr_t * new_tree_expr;
+
+  /* Null argument */
+  if (tree_expr == NULL)
+    return NULL;
+  
+  /* Out of memory */
+  if ((new_tree_expr = (tree_expr_t*)malloc(sizeof(tree_expr_t))) == NULL) 
+    return NULL;
+  
+  /* Set each argument in tree_expr_t struct */
+  new_tree_expr->infix_op = tree_expr->infix_op;  /* infix operators are in shared memory */
+  new_tree_expr->gen_expr = clone_gen_expr(tree_expr->gen_expr); /* clone the general expression */
+  new_tree_expr->left = clone_tree_expr(tree_expr->left); /* clone the left tree expression */
+  new_tree_expr->right = clone_tree_expr(tree_expr->right); /* clone the right tree expression */
+
+  return new_tree_expr; /* Return the new (cloned) tree expression */
+}
+
+/* Clones a value expression, currently only passes the pointer to 
+   the value that this object represents, not a pointer to a copy of the value */
+val_expr_t * clone_val_expr(val_expr_t * val_expr) {
+
+  val_expr_t * new_val_expr;
+
+  /* Null argument */
+  if (val_expr == NULL)
+    return NULL;
+  
+  /* Allocate space, check for out of memory */
+  if ((new_val_expr = (val_expr_t*)malloc(sizeof(val_expr_t))) == NULL) 
+    return NULL;
+
+  /* Set the values in the val_expr_t struct */
+  new_val_expr->type = val_expr->type;
+  new_val_expr->term = val_expr->term;
+  
+  /* Return the new (cloned) value expression */
+  return new_val_expr;
+}
+
+/* Clones a prefix function with its arguments */
+prefun_expr_t * clone_prefun_expr(prefun_expr_t * prefun_expr) {
+
+  int i;
+  prefun_expr_t * new_prefun_expr;
+  
+  /* Null argument */
+  if (prefun_expr == NULL)
+    return NULL;
+  
+  /* Out of memory */
+  if ((new_prefun_expr = (prefun_expr_t*)malloc(sizeof(prefun_expr_t))) == NULL) 
+    return NULL;
+  
+  /* Set the function argument paired with its number of arguments */
+  new_prefun_expr->num_args = prefun_expr->num_args;
+  new_prefun_expr->func_ptr = prefun_expr->func_ptr;
+
+  /* Allocate space for the expression list pointers */
+  if ((new_prefun_expr->expr_list = (gen_expr_t**)malloc(sizeof(gen_expr_t*)*new_prefun_expr->num_args)) == NULL) {
+    free(new_prefun_expr);
+    return NULL;
+  }
+
+  /* Now copy each general expression from the argument expression list */
+  for (i = 0; i < new_prefun_expr->num_args;i++) 
+    new_prefun_expr->expr_list[i] = clone_gen_expr(prefun_expr->expr_list[i]);
+  
+  /* Finally, return the new (cloned) prefix function expression */
+  return new_prefun_expr;
+}
+
+/* Reinitializes the engine variables to a default (conservative and sane) value */
+void reset_engine_vars() {
+
+  zoom=1.0;
+  zoomexp= 1.0;
+  rot= 0.0;
+  warp= 0.0;
+  
+  sx= 1.0;
+  sy= 1.0;
+  dx= 0.0;
+  dy= 0.0;
+  cx= 0.5;
+  cy= 0.5;
+
+  
+  decay=.98;
+  
+  wave_r= 1.0;
+  wave_g= 0.2;
+  wave_b= 0.0;
+  wave_x= 0.5;
+  wave_y= 0.5;
+  wave_mystery= 0.0;
+
+  ob_size= 0.0;
+  ob_r= 0.0;
+  ob_g= 0.0;
+  ob_b= 0.0;
+  ob_a= 0.0;
+
+  ib_size = 0.0;
+  ib_r = 0.0;
+  ib_g = 0.0;
+  ib_b = 0.0;
+  ib_a = 0.0;
+
+  mv_a = 0.0;
+  mv_r = 0.0;
+  mv_g = 0.0;
+  mv_b = 0.0;
+  mv_l = 1.0;
+  mv_x = 16.0;
+  mv_y = 12.0;
+  mv_dy = 0.02;
+  mv_dx = 0.02;
+  
+  meshx = 0;
+  meshy = 0;
+  Time = 0;
+  treb = 0;
+  mid = 0;
+  bass = 0;
+  treb_att = 0;
+  mid_att = 0;
+  bass_att = 0;
+  progress = 0;
+  frame = 0;
+
+// bass_thresh = 0;
+
+/* PER_FRAME CONSTANTS END */
+  fRating = 0;
+  fGammaAdj = 1.0;
+  fVideoEchoZoom = 1.0;
+  fVideoEchoAlpha = 0;
+  nVideoEchoOrientation = 0;
+  nWaveMode = 7;
+  bAdditiveWaves = 0;
+  bWaveDots = 0;
+  bWaveThick = 0;
+  bModWaveAlphaByVolume = 0;
+  bMaximizeWaveColor = 0;
+  bTexWrap = 0;
+  bDarkenCenter = 0;
+  bRedBlueStereo = 0;
+  bBrighten = 0;
+  bDarken = 0;
+  bSolarize = 0;
+ bInvert = 0;
+ bMotionVectorsOn = 1;
+  fWaveAlpha =1.0;
+  fWaveScale = 1.0;
+  fWaveSmoothing = 0;
+  fWaveParam = 0;
+  fModWaveAlphaStart = 0;
+  fModWaveAlphaEnd = 0;
+  fWarpAnimSpeed = 0;
+  fWarpScale = 0;
+  fShader = 0;
+
+
+/* PER_PIXEL CONSTANTS BEGIN */
+ x_per_pixel = 0;
+ y_per_pixel = 0;
+ rad_per_pixel = 0;
+ ang_per_pixel = 0;
+
+/* PER_PIXEL CONSTANT END */
+
+
+/* Q VARIABLES START */
+
+ q1 = 0;
+ q2 = 0;
+ q3 = 0;
+ q4 = 0;
+ q5 = 0;
+ q6 = 0;
+ q7 = 0;
+ q8 = 0;
+
+
+ /* Q VARIABLES END */
+
+
+}
+
+
diff --git a/modules/visualization/galaktos/eval.h b/modules/visualization/galaktos/eval.h
new file mode 100644 (file)
index 0000000..60ae143
--- /dev/null
@@ -0,0 +1,55 @@
+/* eval.h: evaluation functions of expressions */
+#ifndef EVAL_H
+#define EVAL_H
+#include "func_types.h"
+#include "param_types.h"
+
+#define VAL_T 1
+#define PREFUN_T 3
+#define TREE_T 4
+#define NONE_T 0
+
+
+#define CONSTANT_TERM_T 0
+#define PARAM_TERM_T 1
+
+#define INFIX_ADD 0
+#define INFIX_MINUS 1
+#define INFIX_MOD 2
+#define INFIX_DIV 3
+#define INFIX_MULT 4
+#define INFIX_OR 5
+#define INFIX_AND 6
+
+//#define EVAL_DEBUG 
+
+
+inline double eval_gen_expr(gen_expr_t * gen_expr);
+inline gen_expr_t * opt_gen_expr(gen_expr_t * gen_expr, int ** param_list);
+
+gen_expr_t * const_to_expr(double val);
+gen_expr_t * param_to_expr(struct PARAM_T * param);
+gen_expr_t * prefun_to_expr(double (*func_ptr)(), gen_expr_t ** expr_list, int num_args);
+
+tree_expr_t * new_tree_expr(infix_op_t * infix_op, gen_expr_t * gen_expr, tree_expr_t * left, tree_expr_t * right);
+gen_expr_t * new_gen_expr(int type, void * item);
+val_expr_t * new_val_expr(int type, term_t term);
+
+int free_gen_expr(gen_expr_t * gen_expr);
+int free_prefun_expr(prefun_expr_t * prefun_expr);
+int free_tree_expr(tree_expr_t * tree_expr);
+int free_val_expr(val_expr_t * val_expr);
+
+infix_op_t * new_infix_op(int type, int precedence);
+int init_infix_ops();
+int destroy_infix_ops();
+void reset_engine_vars();
+
+gen_expr_t * clone_gen_expr(gen_expr_t * gen_expr);
+tree_expr_t * clone_tree_expr(tree_expr_t * tree_expr);
+val_expr_t * clone_val_expr(val_expr_t * val_expr);
+prefun_expr_t * clone_prefun_expr(prefun_expr_t * prefun_expr);
+
+
+
+#endif
diff --git a/modules/visualization/galaktos/expr_types.h b/modules/visualization/galaktos/expr_types.h
new file mode 100644 (file)
index 0000000..a5563f0
--- /dev/null
@@ -0,0 +1,48 @@
+#ifndef EXPR_TYPES_H
+#define EXPR_TYPES_H
+#include "param_types.h"
+
+#define CONST_STACK_ELEMENT 0
+#define EXPR_STACK_ELEMENT 1
+
+/* General Expression Type */
+typedef struct GEN_EXPR_T {
+  int type;
+  void * item;
+} gen_expr_t;
+
+typedef union TERM_T {
+  double constant; /* static variable */
+  struct PARAM_T * param; /* pointer to a changing variable */
+} term_t;
+
+/* Value expression, contains a term union */
+typedef struct VAL_EXPR_T {
+  int type;
+  term_t term;
+} val_expr_t;
+
+/* Infix Operator Function */
+typedef struct INFIX_OP_T {
+  int type;
+  int precedence;  
+} infix_op_t;
+
+/* A binary expression tree ordered by operator precedence */
+typedef struct TREE_EXPR_T {
+  infix_op_t * infix_op; /* null if leaf */
+  gen_expr_t * gen_expr;
+  struct TREE_EXPR_T * left, * right;
+} tree_expr_t;
+
+/* A function expression in prefix form */
+typedef struct PREFUN_EXPR_T {
+  double (*func_ptr)();
+  int num_args;
+  gen_expr_t ** expr_list;
+} prefun_expr_t;
+
+
+
+
+#endif
diff --git a/modules/visualization/galaktos/fatal.h b/modules/visualization/galaktos/fatal.h
new file mode 100644 (file)
index 0000000..352bccb
--- /dev/null
@@ -0,0 +1,9 @@
+/* Fatal Error Definitions */
+
+#define OUTOFMEM_ERROR -7; /* out of memory */
+#define ERROR -1 /* non specific error */
+#define SUCCESS 1
+#define FAILURE -1
+#define PARSE_ERROR -11
+#define DIV_BY_ZERO -3
+#define OK 2
diff --git a/modules/visualization/galaktos/fftsg.c b/modules/visualization/galaktos/fftsg.c
new file mode 100644 (file)
index 0000000..9564121
--- /dev/null
@@ -0,0 +1,3340 @@
+/*****************************************************************************
+ * fftsg.c:
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id$
+ *
+ * Authors: Cyril Deguet <asmax@videolan.org>
+ *          code from projectM http://xmms-projectm.sourceforge.net
+ *
+ * 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, USA.
+ *****************************************************************************/
+
+
+
+/*
+Fast Fourier/Cosine/Sine Transform
+    dimension   :one
+    data length :power of 2
+    decimation  :frequency
+    radix       :split-radix
+    data        :inplace
+    table       :use
+functions
+    cdft: Complex Discrete Fourier Transform
+    rdft: Real Discrete Fourier Transform
+    ddct: Discrete Cosine Transform
+    ddst: Discrete Sine Transform
+    dfct: Cosine Transform of RDFT (Real Symmetric DFT)
+    dfst: Sine Transform of RDFT (Real Anti-symmetric DFT)
+function prototypes
+    void cdft(int, int, double *, int *, double *);
+    void rdft(int, int, double *, int *, double *);
+    void ddct(int, int, double *, int *, double *);
+    void ddst(int, int, double *, int *, double *);
+    void dfct(int, double *, double *, int *, double *);
+    void dfst(int, double *, double *, int *, double *);
+macro definitions
+    USE_CDFT_PTHREADS : default=not defined
+        CDFT_THREADS_BEGIN_N  : must be >= 512, default=8192
+        CDFT_4THREADS_BEGIN_N : must be >= 512, default=65536
+    USE_CDFT_WINTHREADS : default=not defined
+        CDFT_THREADS_BEGIN_N  : must be >= 512, default=32768
+        CDFT_4THREADS_BEGIN_N : must be >= 512, default=524288
+
+
+-------- Complex DFT (Discrete Fourier Transform) --------
+    [definition]
+        <case1>
+            X[k] = sum_j=0^n-1 x[j]*exp(2*pi*i*j*k/n), 0<=k<n
+        <case2>
+            X[k] = sum_j=0^n-1 x[j]*exp(-2*pi*i*j*k/n), 0<=k<n
+        (notes: sum_j=0^n-1 is a summation from j=0 to n-1)
+    [usage]
+        <case1>
+            ip[0] = 0; // first time only
+            cdft(2*n, 1, a, ip, w);
+        <case2>
+            ip[0] = 0; // first time only
+            cdft(2*n, -1, a, ip, w);
+    [parameters]
+        2*n            :data length (int)
+                        n >= 1, n = power of 2
+        a[0...2*n-1]   :input/output data (double *)
+                        input data
+                            a[2*j] = Re(x[j]), 
+                            a[2*j+1] = Im(x[j]), 0<=j<n
+                        output data
+                            a[2*k] = Re(X[k]), 
+                            a[2*k+1] = Im(X[k]), 0<=k<n
+        ip[0...*]      :work area for bit reversal (int *)
+                        length of ip >= 2+sqrt(n)
+                        strictly, 
+                        length of ip >= 
+                            2+(1<<(int)(log(n+0.5)/log(2))/2).
+                        ip[0],ip[1] are pointers of the cos/sin table.
+        w[0...n/2-1]   :cos/sin table (double *)
+                        w[],ip[] are initialized if ip[0] == 0.
+    [remark]
+        Inverse of 
+            cdft(2*n, -1, a, ip, w);
+        is 
+            cdft(2*n, 1, a, ip, w);
+            for (j = 0; j <= 2 * n - 1; j++) {
+                a[j] *= 1.0 / n;
+            }
+        .
+
+
+-------- Real DFT / Inverse of Real DFT --------
+    [definition]
+        <case1> RDFT
+            R[k] = sum_j=0^n-1 a[j]*cos(2*pi*j*k/n), 0<=k<=n/2
+            I[k] = sum_j=0^n-1 a[j]*sin(2*pi*j*k/n), 0<k<n/2
+        <case2> IRDFT (excluding scale)
+            a[k] = (R[0] + R[n/2]*cos(pi*k))/2 + 
+                   sum_j=1^n/2-1 R[j]*cos(2*pi*j*k/n) + 
+                   sum_j=1^n/2-1 I[j]*sin(2*pi*j*k/n), 0<=k<n
+    [usage]
+        <case1>
+            ip[0] = 0; // first time only
+            rdft(n, 1, a, ip, w);
+        <case2>
+            ip[0] = 0; // first time only
+            rdft(n, -1, a, ip, w);
+    [parameters]
+        n              :data length (int)
+                        n >= 2, n = power of 2
+        a[0...n-1]     :input/output data (double *)
+                        <case1>
+                            output data
+                                a[2*k] = R[k], 0<=k<n/2
+                                a[2*k+1] = I[k], 0<k<n/2
+                                a[1] = R[n/2]
+                        <case2>
+                            input data
+                                a[2*j] = R[j], 0<=j<n/2
+                                a[2*j+1] = I[j], 0<j<n/2
+                                a[1] = R[n/2]
+        ip[0...*]      :work area for bit reversal (int *)
+                        length of ip >= 2+sqrt(n/2)
+                        strictly, 
+                        length of ip >= 
+                            2+(1<<(int)(log(n/2+0.5)/log(2))/2).
+                        ip[0],ip[1] are pointers of the cos/sin table.
+        w[0...n/2-1]   :cos/sin table (double *)
+                        w[],ip[] are initialized if ip[0] == 0.
+    [remark]
+        Inverse of 
+            rdft(n, 1, a, ip, w);
+        is 
+            rdft(n, -1, a, ip, w);
+            for (j = 0; j <= n - 1; j++) {
+                a[j] *= 2.0 / n;
+            }
+        .
+
+
+-------- DCT (Discrete Cosine Transform) / Inverse of DCT --------
+    [definition]
+        <case1> IDCT (excluding scale)
+            C[k] = sum_j=0^n-1 a[j]*cos(pi*j*(k+1/2)/n), 0<=k<n
+        <case2> DCT
+            C[k] = sum_j=0^n-1 a[j]*cos(pi*(j+1/2)*k/n), 0<=k<n
+    [usage]
+        <case1>
+            ip[0] = 0; // first time only
+            ddct(n, 1, a, ip, w);
+        <case2>
+            ip[0] = 0; // first time only
+            ddct(n, -1, a, ip, w);
+    [parameters]
+        n              :data length (int)
+                        n >= 2, n = power of 2
+        a[0...n-1]     :input/output data (double *)
+                        output data
+                            a[k] = C[k], 0<=k<n
+        ip[0...*]      :work area for bit reversal (int *)
+                        length of ip >= 2+sqrt(n/2)
+                        strictly, 
+                        length of ip >= 
+                            2+(1<<(int)(log(n/2+0.5)/log(2))/2).
+                        ip[0],ip[1] are pointers of the cos/sin table.
+        w[0...n*5/4-1] :cos/sin table (double *)
+                        w[],ip[] are initialized if ip[0] == 0.
+    [remark]
+        Inverse of 
+            ddct(n, -1, a, ip, w);
+        is 
+            a[0] *= 0.5;
+            ddct(n, 1, a, ip, w);
+            for (j = 0; j <= n - 1; j++) {
+                a[j] *= 2.0 / n;
+            }
+        .
+
+
+-------- DST (Discrete Sine Transform) / Inverse of DST --------
+    [definition]
+        <case1> IDST (excluding scale)
+            S[k] = sum_j=1^n A[j]*sin(pi*j*(k+1/2)/n), 0<=k<n
+        <case2> DST
+            S[k] = sum_j=0^n-1 a[j]*sin(pi*(j+1/2)*k/n), 0<k<=n
+    [usage]
+        <case1>
+            ip[0] = 0; // first time only
+            ddst(n, 1, a, ip, w);
+        <case2>
+            ip[0] = 0; // first time only
+            ddst(n, -1, a, ip, w);
+    [parameters]
+        n              :data length (int)
+                        n >= 2, n = power of 2
+        a[0...n-1]     :input/output data (double *)
+                        <case1>
+                            input data
+                                a[j] = A[j], 0<j<n
+                                a[0] = A[n]
+                            output data
+                                a[k] = S[k], 0<=k<n
+                        <case2>
+                            output data
+                                a[k] = S[k], 0<k<n
+                                a[0] = S[n]
+        ip[0...*]      :work area for bit reversal (int *)
+                        length of ip >= 2+sqrt(n/2)
+                        strictly, 
+                        length of ip >= 
+                            2+(1<<(int)(log(n/2+0.5)/log(2))/2).
+                        ip[0],ip[1] are pointers of the cos/sin table.
+        w[0...n*5/4-1] :cos/sin table (double *)
+                        w[],ip[] are initialized if ip[0] == 0.
+    [remark]
+        Inverse of 
+            ddst(n, -1, a, ip, w);
+        is 
+            a[0] *= 0.5;
+            ddst(n, 1, a, ip, w);
+            for (j = 0; j <= n - 1; j++) {
+                a[j] *= 2.0 / n;
+            }
+        .
+
+
+-------- Cosine Transform of RDFT (Real Symmetric DFT) --------
+    [definition]
+        C[k] = sum_j=0^n a[j]*cos(pi*j*k/n), 0<=k<=n
+    [usage]
+        ip[0] = 0; // first time only
+        dfct(n, a, t, ip, w);
+    [parameters]
+        n              :data length - 1 (int)
+                        n >= 2, n = power of 2
+        a[0...n]       :input/output data (double *)
+                        output data
+                            a[k] = C[k], 0<=k<=n
+        t[0...n/2]     :work area (double *)
+        ip[0...*]      :work area for bit reversal (int *)
+                        length of ip >= 2+sqrt(n/4)
+                        strictly, 
+                        length of ip >= 
+                            2+(1<<(int)(log(n/4+0.5)/log(2))/2).
+                        ip[0],ip[1] are pointers of the cos/sin table.
+        w[0...n*5/8-1] :cos/sin table (double *)
+                        w[],ip[] are initialized if ip[0] == 0.
+    [remark]
+        Inverse of 
+            a[0] *= 0.5;
+            a[n] *= 0.5;
+            dfct(n, a, t, ip, w);
+        is 
+            a[0] *= 0.5;
+            a[n] *= 0.5;
+            dfct(n, a, t, ip, w);
+            for (j = 0; j <= n; j++) {
+                a[j] *= 2.0 / n;
+            }
+        .
+
+
+-------- Sine Transform of RDFT (Real Anti-symmetric DFT) --------
+    [definition]
+        S[k] = sum_j=1^n-1 a[j]*sin(pi*j*k/n), 0<k<n
+    [usage]
+        ip[0] = 0; // first time only
+        dfst(n, a, t, ip, w);
+    [parameters]
+        n              :data length + 1 (int)
+                        n >= 2, n = power of 2
+        a[0...n-1]     :input/output data (double *)
+                        output data
+                            a[k] = S[k], 0<k<n
+                        (a[0] is used for work area)
+        t[0...n/2-1]   :work area (double *)
+        ip[0...*]      :work area for bit reversal (int *)
+                        length of ip >= 2+sqrt(n/4)
+                        strictly, 
+                        length of ip >= 
+                            2+(1<<(int)(log(n/4+0.5)/log(2))/2).
+                        ip[0],ip[1] are pointers of the cos/sin table.
+        w[0...n*5/8-1] :cos/sin table (double *)
+                        w[],ip[] are initialized if ip[0] == 0.
+    [remark]
+        Inverse of 
+            dfst(n, a, t, ip, w);
+        is 
+            dfst(n, a, t, ip, w);
+            for (j = 1; j <= n - 1; j++) {
+                a[j] *= 2.0 / n;
+            }
+        .
+
+
+Appendix :
+    The cos/sin table is recalculated when the larger table required.
+    w[] and ip[] are compatible with all routines.
+*/
+
+
+void cdft(int n, int isgn, double *a, int *ip, double *w)
+{
+    void makewt(int nw, int *ip, double *w);
+    void cftfsub(int n, double *a, int *ip, int nw, double *w);
+    void cftbsub(int n, double *a, int *ip, int nw, double *w);
+    int nw;
+    
+    nw = ip[0];
+    if (n > (nw << 2)) {
+        nw = n >> 2;
+        makewt(nw, ip, w);
+    }
+    if (isgn >= 0) {
+        cftfsub(n, a, ip, nw, w);
+    } else {
+        cftbsub(n, a, ip, nw, w);
+    }
+}
+
+
+void rdft(int n, int isgn, double *a, int *ip, double *w)
+{
+    void makewt(int nw, int *ip, double *w);
+    void makect(int nc, int *ip, double *c);
+    void cftfsub(int n, double *a, int *ip, int nw, double *w);
+    void cftbsub(int n, double *a, int *ip, int nw, double *w);
+    void rftfsub(int n, double *a, int nc, double *c);
+    void rftbsub(int n, double *a, int nc, double *c);
+    int nw, nc;
+    double xi;
+    
+    nw = ip[0];
+    if (n > (nw << 2)) {
+        nw = n >> 2;
+        makewt(nw, ip, w);
+    }
+    nc = ip[1];
+    if (n > (nc << 2)) {
+        nc = n >> 2;
+        makect(nc, ip, w + nw);
+    }
+    if (isgn >= 0) {
+        if (n > 4) {
+            cftfsub(n, a, ip, nw, w);
+            rftfsub(n, a, nc, w + nw);
+        } else if (n == 4) {
+            cftfsub(n, a, ip, nw, w);
+        }
+        xi = a[0] - a[1];
+        a[0] += a[1];
+        a[1] = xi;
+    } else {
+        a[1] = 0.5 * (a[0] - a[1]);
+        a[0] -= a[1];
+        if (n > 4) {
+            rftbsub(n, a, nc, w + nw);
+            cftbsub(n, a, ip, nw, w);
+        } else if (n == 4) {
+            cftbsub(n, a, ip, nw, w);
+        }
+    }
+}
+
+
+void ddct(int n, int isgn, double *a, int *ip, double *w)
+{
+    void makewt(int nw, int *ip, double *w);
+    void makect(int nc, int *ip, double *c);
+    void cftfsub(int n, double *a, int *ip, int nw, double *w);
+    void cftbsub(int n, double *a, int *ip, int nw, double *w);
+    void rftfsub(int n, double *a, int nc, double *c);
+    void rftbsub(int n, double *a, int nc, double *c);
+    void dctsub(int n, double *a, int nc, double *c);
+    int j, nw, nc;
+    double xr;
+    
+    nw = ip[0];
+    if (n > (nw << 2)) {
+        nw = n >> 2;
+        makewt(nw, ip, w);
+    }
+    nc = ip[1];
+    if (n > nc) {
+        nc = n;
+        makect(nc, ip, w + nw);
+    }
+    if (isgn < 0) {
+        xr = a[n - 1];
+        for (j = n - 2; j >= 2; j -= 2) {
+            a[j + 1] = a[j] - a[j - 1];
+            a[j] += a[j - 1];
+        }
+        a[1] = a[0] - xr;
+        a[0] += xr;
+        if (n > 4) {
+            rftbsub(n, a, nc, w + nw);
+            cftbsub(n, a, ip, nw, w);
+        } else if (n == 4) {
+            cftbsub(n, a, ip, nw, w);
+        }
+    }
+    dctsub(n, a, nc, w + nw);
+    if (isgn >= 0) {
+        if (n > 4) {
+            cftfsub(n, a, ip, nw, w);
+            rftfsub(n, a, nc, w + nw);
+        } else if (n == 4) {
+            cftfsub(n, a, ip, nw, w);
+        }
+        xr = a[0] - a[1];
+        a[0] += a[1];
+        for (j = 2; j < n; j += 2) {
+            a[j - 1] = a[j] - a[j + 1];
+            a[j] += a[j + 1];
+        }
+        a[n - 1] = xr;
+    }
+}
+
+
+void ddst(int n, int isgn, double *a, int *ip, double *w)
+{
+    void makewt(int nw, int *ip, double *w);
+    void makect(int nc, int *ip, double *c);
+    void cftfsub(int n, double *a, int *ip, int nw, double *w);
+    void cftbsub(int n, double *a, int *ip, int nw, double *w);
+    void rftfsub(int n, double *a, int nc, double *c);
+    void rftbsub(int n, double *a, int nc, double *c);
+    void dstsub(int n, double *a, int nc, double *c);
+    int j, nw, nc;
+    double xr;
+    
+    nw = ip[0];
+    if (n > (nw << 2)) {
+        nw = n >> 2;
+        makewt(nw, ip, w);
+    }
+    nc = ip[1];
+    if (n > nc) {
+        nc = n;
+        makect(nc, ip, w + nw);
+    }
+    if (isgn < 0) {
+        xr = a[n - 1];
+        for (j = n - 2; j >= 2; j -= 2) {
+            a[j + 1] = -a[j] - a[j - 1];
+            a[j] -= a[j - 1];
+        }
+        a[1] = a[0] + xr;
+        a[0] -= xr;
+        if (n > 4) {
+            rftbsub(n, a, nc, w + nw);
+            cftbsub(n, a, ip, nw, w);
+        } else if (n == 4) {
+            cftbsub(n, a, ip, nw, w);
+        }
+    }
+    dstsub(n, a, nc, w + nw);
+    if (isgn >= 0) {
+        if (n > 4) {
+            cftfsub(n, a, ip, nw, w);
+            rftfsub(n, a, nc, w + nw);
+        } else if (n == 4) {
+            cftfsub(n, a, ip, nw, w);
+        }
+        xr = a[0] - a[1];
+        a[0] += a[1];
+        for (j = 2; j < n; j += 2) {
+            a[j - 1] = -a[j] - a[j + 1];
+            a[j] -= a[j + 1];
+        }
+        a[n - 1] = -xr;
+    }
+}
+
+
+void dfct(int n, double *a, double *t, int *ip, double *w)
+{
+    void makewt(int nw, int *ip, double *w);
+    void makect(int nc, int *ip, double *c);
+    void cftfsub(int n, double *a, int *ip, int nw, double *w);
+    void rftfsub(int n, double *a, int nc, double *c);
+    void dctsub(int n, double *a, int nc, double *c);
+    int j, k, l, m, mh, nw, nc;
+    double xr, xi, yr, yi;
+    
+    nw = ip[0];
+    if (n > (nw << 3)) {
+        nw = n >> 3;
+        makewt(nw, ip, w);
+    }
+    nc = ip[1];
+    if (n > (nc << 1)) {
+        nc = n >> 1;
+        makect(nc, ip, w + nw);
+    }
+    m = n >> 1;
+    yi = a[m];
+    xi = a[0] + a[n];
+    a[0] -= a[n];
+    t[0] = xi - yi;
+    t[m] = xi + yi;
+    if (n > 2) {
+        mh = m >> 1;
+        for (j = 1; j < mh; j++) {
+            k = m - j;
+            xr = a[j] - a[n - j];
+            xi = a[j] + a[n - j];
+            yr = a[k] - a[n - k];
+            yi = a[k] + a[n - k];
+            a[j] = xr;
+            a[k] = yr;
+            t[j] = xi - yi;
+            t[k] = xi + yi;
+        }
+        t[mh] = a[mh] + a[n - mh];
+        a[mh] -= a[n - mh];
+        dctsub(m, a, nc, w + nw);
+        if (m > 4) {
+            cftfsub(m, a, ip, nw, w);
+            rftfsub(m, a, nc, w + nw);
+        } else if (m == 4) {
+            cftfsub(m, a, ip, nw, w);
+        }
+        a[n - 1] = a[0] - a[1];
+        a[1] = a[0] + a[1];
+        for (j = m - 2; j >= 2; j -= 2) {
+            a[2 * j + 1] = a[j] + a[j + 1];
+            a[2 * j - 1] = a[j] - a[j + 1];
+        }
+        l = 2;
+        m = mh;
+        while (m >= 2) {
+            dctsub(m, t, nc, w + nw);
+            if (m > 4) {
+                cftfsub(m, t, ip, nw, w);
+                rftfsub(m, t, nc, w + nw);
+            } else if (m == 4) {
+                cftfsub(m, t, ip, nw, w);
+            }
+            a[n - l] = t[0] - t[1];
+            a[l] = t[0] + t[1];
+            k = 0;
+            for (j = 2; j < m; j += 2) {
+                k += l << 2;
+                a[k - l] = t[j] - t[j + 1];
+                a[k + l] = t[j] + t[j + 1];
+            }
+            l <<= 1;
+            mh = m >> 1;
+            for (j = 0; j < mh; j++) {
+                k = m - j;
+                t[j] = t[m + k] - t[m + j];
+                t[k] = t[m + k] + t[m + j];
+            }
+            t[mh] = t[m + mh];
+            m = mh;
+        }
+        a[l] = t[0];
+        a[n] = t[2] - t[1];
+        a[0] = t[2] + t[1];
+    } else {
+        a[1] = a[0];
+        a[2] = t[0];
+        a[0] = t[1];
+    }
+}
+
+
+void dfst(int n, double *a, double *t, int *ip, double *w)
+{
+    void makewt(int nw, int *ip, double *w);
+    void makect(int nc, int *ip, double *c);
+    void cftfsub(int n, double *a, int *ip, int nw, double *w);
+    void rftfsub(int n, double *a, int nc, double *c);
+    void dstsub(int n, double *a, int nc, double *c);
+    int j, k, l, m, mh, nw, nc;
+    double xr, xi, yr, yi;
+    
+    nw = ip[0];
+    if (n > (nw << 3)) {
+        nw = n >> 3;
+        makewt(nw, ip, w);
+    }
+    nc = ip[1];
+    if (n > (nc << 1)) {
+        nc = n >> 1;
+        makect(nc, ip, w + nw);
+    }
+    if (n > 2) {
+        m = n >> 1;
+        mh = m >> 1;
+        for (j = 1; j < mh; j++) {
+            k = m - j;
+            xr = a[j] + a[n - j];
+            xi = a[j] - a[n - j];
+            yr = a[k] + a[n - k];
+            yi = a[k] - a[n - k];
+            a[j] = xr;
+            a[k] = yr;
+            t[j] = xi + yi;
+            t[k] = xi - yi;
+        }
+        t[0] = a[mh] - a[n - mh];
+        a[mh] += a[n - mh];
+        a[0] = a[m];
+        dstsub(m, a, nc, w + nw);
+        if (m > 4) {
+            cftfsub(m, a, ip, nw, w);
+            rftfsub(m, a, nc, w + nw);
+        } else if (m == 4) {
+            cftfsub(m, a, ip, nw, w);
+        }
+        a[n - 1] = a[1] - a[0];
+        a[1] = a[0] + a[1];
+        for (j = m - 2; j >= 2; j -= 2) {
+            a[2 * j + 1] = a[j] - a[j + 1];
+            a[2 * j - 1] = -a[j] - a[j + 1];
+        }
+        l = 2;
+        m = mh;
+        while (m >= 2) {
+            dstsub(m, t, nc, w + nw);
+            if (m > 4) {
+                cftfsub(m, t, ip, nw, w);
+                rftfsub(m, t, nc, w + nw);
+            } else if (m == 4) {
+                cftfsub(m, t, ip, nw, w);
+            }
+            a[n - l] = t[1] - t[0];
+            a[l] = t[0] + t[1];
+            k = 0;
+            for (j = 2; j < m; j += 2) {
+                k += l << 2;
+                a[k - l] = -t[j] - t[j + 1];
+                a[k + l] = t[j] - t[j + 1];
+            }
+            l <<= 1;
+            mh = m >> 1;
+            for (j = 1; j < mh; j++) {
+                k = m - j;
+                t[j] = t[m + k] + t[m + j];
+                t[k] = t[m + k] - t[m + j];
+            }
+            t[0] = t[m + mh];
+            m = mh;
+        }
+        a[l] = t[0];
+    }
+    a[0] = 0;
+}
+
+
+/* -------- initializing routines -------- */
+
+
+#include <math.h>
+
+void makewt(int nw, int *ip, double *w)
+{
+    void makeipt(int nw, int *ip);
+    int j, nwh, nw0, nw1;
+    double delta, wn4r, wk1r, wk1i, wk3r, wk3i;
+    
+    ip[0] = nw;
+    ip[1] = 1;
+    if (nw > 2) {
+        nwh = nw >> 1;
+        delta = atan(1.0) / nwh;
+        wn4r = cos(delta * nwh);
+        w[0] = 1;
+        w[1] = wn4r;
+        if (nwh == 4) {
+            w[2] = cos(delta * 2);
+            w[3] = sin(delta * 2);
+        } else if (nwh > 4) {
+            makeipt(nw, ip);
+            w[2] = 0.5 / cos(delta * 2);
+            w[3] = 0.5 / cos(delta * 6);
+            for (j = 4; j < nwh; j += 4) {
+                w[j] = cos(delta * j);
+                w[j + 1] = sin(delta * j);
+                w[j + 2] = cos(3 * delta * j);
+                w[j + 3] = -sin(3 * delta * j);
+            }
+        }
+        nw0 = 0;
+        while (nwh > 2) {
+            nw1 = nw0 + nwh;
+            nwh >>= 1;
+            w[nw1] = 1;
+            w[nw1 + 1] = wn4r;
+            if (nwh == 4) {
+                wk1r = w[nw0 + 4];
+                wk1i = w[nw0 + 5];
+                w[nw1 + 2] = wk1r;
+                w[nw1 + 3] = wk1i;
+            } else if (nwh > 4) {
+                wk1r = w[nw0 + 4];
+                wk3r = w[nw0 + 6];
+                w[nw1 + 2] = 0.5 / wk1r;
+                w[nw1 + 3] = 0.5 / wk3r;
+                for (j = 4; j < nwh; j += 4) {
+                    wk1r = w[nw0 + 2 * j];
+                    wk1i = w[nw0 + 2 * j + 1];
+                    wk3r = w[nw0 + 2 * j + 2];
+                    wk3i = w[nw0 + 2 * j + 3];
+                    w[nw1 + j] = wk1r;
+                    w[nw1 + j + 1] = wk1i;
+                    w[nw1 + j + 2] = wk3r;
+                    w[nw1 + j + 3] = wk3i;
+                }
+            }
+            nw0 = nw1;
+        }
+    }
+}
+
+
+void makeipt(int nw, int *ip)
+{
+    int j, l, m, m2, p, q;
+    
+    ip[2] = 0;
+    ip[3] = 16;
+    m = 2;
+    for (l = nw; l > 32; l >>= 2) {
+        m2 = m << 1;
+        q = m2 << 3;
+        for (j = m; j < m2; j++) {
+            p = ip[j] << 2;
+            ip[m + j] = p;
+            ip[m2 + j] = p + q;
+        }
+        m = m2;
+    }
+}
+
+
+void makect(int nc, int *ip, double *c)
+{
+    int j, nch;
+    double delta;
+    
+    ip[1] = nc;
+    if (nc > 1) {
+        nch = nc >> 1;
+        delta = atan(1.0) / nch;
+        c[0] = cos(delta * nch);
+        c[nch] = 0.5 * c[0];
+        for (j = 1; j < nch; j++) {
+            c[j] = 0.5 * cos(delta * j);
+            c[nc - j] = 0.5 * sin(delta * j);
+        }
+    }
+}
+
+
+/* -------- child routines -------- */
+
+
+#ifdef USE_CDFT_PTHREADS
+#define USE_CDFT_THREADS
+#ifndef CDFT_THREADS_BEGIN_N
+#define CDFT_THREADS_BEGIN_N 8192
+#endif
+#ifndef CDFT_4THREADS_BEGIN_N
+#define CDFT_4THREADS_BEGIN_N 65536
+#endif
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define cdft_thread_t pthread_t
+#define cdft_thread_create(thp,func,argp) { \
+    if (pthread_create(thp, NULL, func, (void *) argp) != 0) { \
+        fprintf(stderr, "cdft thread error\n"); \
+        exit(1); \
+    } \
+}
+#define cdft_thread_wait(th) { \
+    if (pthread_join(th, NULL) != 0) { \
+        fprintf(stderr, "cdft thread error\n"); \
+        exit(1); \
+    } \
+}
+#endif /* USE_CDFT_PTHREADS */
+
+
+#ifdef USE_CDFT_WINTHREADS
+#define USE_CDFT_THREADS
+#ifndef CDFT_THREADS_BEGIN_N
+#define CDFT_THREADS_BEGIN_N 32768
+#endif
+#ifndef CDFT_4THREADS_BEGIN_N
+#define CDFT_4THREADS_BEGIN_N 524288
+#endif
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define cdft_thread_t HANDLE
+#define cdft_thread_create(thp,func,argp) { \
+    DWORD thid; \
+    *(thp) = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) func, (LPVOID) argp, 0, &thid); \
+    if (*(thp) == 0) { \
+        fprintf(stderr, "cdft thread error\n"); \
+        exit(1); \
+    } \
+}
+#define cdft_thread_wait(th) { \
+    WaitForSingleObject(th, INFINITE); \
+    CloseHandle(th); \
+}
+#endif /* USE_CDFT_WINTHREADS */
+
+
+void cftfsub(int n, double *a, int *ip, int nw, double *w)
+{
+    void bitrv2(int n, int *ip, double *a);
+    void bitrv216(double *a);
+    void bitrv208(double *a);
+    void cftf1st(int n, double *a, double *w);
+    void cftrec4(int n, double *a, int nw, double *w);
+    void cftleaf(int n, int isplt, double *a, int nw, double *w);
+    void cftfx41(int n, double *a, int nw, double *w);
+    void cftf161(double *a, double *w);
+    void cftf081(double *a, double *w);
+    void cftf040(double *a);
+    void cftx020(double *a);
+#ifdef USE_CDFT_THREADS
+    void cftrec4_th(int n, double *a, int nw, double *w);
+#endif /* USE_CDFT_THREADS */
+    
+    if (n > 8) {
+        if (n > 32) {
+            cftf1st(n, a, &w[nw - (n >> 2)]);
+#ifdef USE_CDFT_THREADS
+            if (n > CDFT_THREADS_BEGIN_N) {
+                cftrec4_th(n, a, nw, w);
+            } else 
+#endif /* USE_CDFT_THREADS */
+            if (n > 512) {
+                cftrec4(n, a, nw, w);
+            } else if (n > 128) {
+                cftleaf(n, 1, a, nw, w);
+            } else {
+                cftfx41(n, a, nw, w);
+            }
+            bitrv2(n, ip, a);
+        } else if (n == 32) {
+            cftf161(a, &w[nw - 8]);
+            bitrv216(a);
+        } else {
+            cftf081(a, w);
+            bitrv208(a);
+        }
+    } else if (n == 8) {
+        cftf040(a);
+    } else if (n == 4) {
+        cftx020(a);
+    }
+}
+
+
+void cftbsub(int n, double *a, int *ip, int nw, double *w)
+{
+    void bitrv2conj(int n, int *ip, double *a);
+    void bitrv216neg(double *a);
+    void bitrv208neg(double *a);
+    void cftb1st(int n, double *a, double *w);
+    void cftrec4(int n, double *a, int nw, double *w);
+    void cftleaf(int n, int isplt, double *a, int nw, double *w);
+    void cftfx41(int n, double *a, int nw, double *w);
+    void cftf161(double *a, double *w);
+    void cftf081(double *a, double *w);
+    void cftb040(double *a);
+    void cftx020(double *a);
+#ifdef USE_CDFT_THREADS
+    void cftrec4_th(int n, double *a, int nw, double *w);
+#endif /* USE_CDFT_THREADS */
+    
+    if (n > 8) {
+        if (n > 32) {
+            cftb1st(n, a, &w[nw - (n >> 2)]);
+#ifdef USE_CDFT_THREADS
+            if (n > CDFT_THREADS_BEGIN_N) {
+                cftrec4_th(n, a, nw, w);
+            } else 
+#endif /* USE_CDFT_THREADS */
+            if (n > 512) {
+                cftrec4(n, a, nw, w);
+            } else if (n > 128) {
+                cftleaf(n, 1, a, nw, w);
+            } else {
+                cftfx41(n, a, nw, w);
+            }
+            bitrv2conj(n, ip, a);
+        } else if (n == 32) {
+            cftf161(a, &w[nw - 8]);
+            bitrv216neg(a);
+        } else {
+            cftf081(a, w);
+            bitrv208neg(a);
+        }
+    } else if (n == 8) {
+        cftb040(a);
+    } else if (n == 4) {
+        cftx020(a);
+    }
+}
+
+
+void bitrv2(int n, int *ip, double *a)
+{
+    int j, j1, k, k1, l, m, nh, nm;
+    double xr, xi, yr, yi;
+    
+    m = 1;
+    for (l = n >> 2; l > 8; l >>= 2) {
+        m <<= 1;
+    }
+    nh = n >> 1;
+    nm = 4 * m;
+    if (l == 8) {
+        for (k = 0; k < m; k++) {
+            for (j = 0; j < k; j++) {
+                j1 = 4 * j + 2 * ip[m + k];
+                k1 = 4 * k + 2 * ip[m + j];
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nh;
+                k1 += 2;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += 2;
+                k1 += nh;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nh;
+                k1 -= 2;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+            }
+            k1 = 4 * k + 2 * ip[m + k];
+            j1 = k1 + 2;
+            k1 += nh;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += nm;
+            k1 += 2 * nm;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += nm;
+            k1 -= nm;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 -= 2;
+            k1 -= nh;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += nh + 2;
+            k1 += nh + 2;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 -= nh - nm;
+            k1 += 2 * nm - 2;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+        }
+    } else {
+        for (k = 0; k < m; k++) {
+            for (j = 0; j < k; j++) {
+                j1 = 4 * j + ip[m + k];
+                k1 = 4 * k + ip[m + j];
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nh;
+                k1 += 2;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += 2;
+                k1 += nh;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nh;
+                k1 -= 2;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+            }
+            k1 = 4 * k + ip[m + k];
+            j1 = k1 + 2;
+            k1 += nh;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += nm;
+            k1 += nm;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+        }
+    }
+}
+
+
+void bitrv2conj(int n, int *ip, double *a)
+{
+    int j, j1, k, k1, l, m, nh, nm;
+    double xr, xi, yr, yi;
+    
+    m = 1;
+    for (l = n >> 2; l > 8; l >>= 2) {
+        m <<= 1;
+    }
+    nh = n >> 1;
+    nm = 4 * m;
+    if (l == 8) {
+        for (k = 0; k < m; k++) {
+            for (j = 0; j < k; j++) {
+                j1 = 4 * j + 2 * ip[m + k];
+                k1 = 4 * k + 2 * ip[m + j];
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nh;
+                k1 += 2;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += 2;
+                k1 += nh;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nh;
+                k1 -= 2;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+            }
+            k1 = 4 * k + 2 * ip[m + k];
+            j1 = k1 + 2;
+            k1 += nh;
+            a[j1 - 1] = -a[j1 - 1];
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            a[k1 + 3] = -a[k1 + 3];
+            j1 += nm;
+            k1 += 2 * nm;
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += nm;
+            k1 -= nm;
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 -= 2;
+            k1 -= nh;
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += nh + 2;
+            k1 += nh + 2;
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 -= nh - nm;
+            k1 += 2 * nm - 2;
+            a[j1 - 1] = -a[j1 - 1];
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            a[k1 + 3] = -a[k1 + 3];
+        }
+    } else {
+        for (k = 0; k < m; k++) {
+            for (j = 0; j < k; j++) {
+                j1 = 4 * j + ip[m + k];
+                k1 = 4 * k + ip[m + j];
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nh;
+                k1 += 2;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += 2;
+                k1 += nh;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nh;
+                k1 -= 2;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+            }
+            k1 = 4 * k + ip[m + k];
+            j1 = k1 + 2;
+            k1 += nh;
+            a[j1 - 1] = -a[j1 - 1];
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            a[k1 + 3] = -a[k1 + 3];
+            j1 += nm;
+            k1 += nm;
+            a[j1 - 1] = -a[j1 - 1];
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            a[k1 + 3] = -a[k1 + 3];
+        }
+    }
+}
+
+
+void bitrv216(double *a)
+{
+    double x1r, x1i, x2r, x2i, x3r, x3i, x4r, x4i, 
+        x5r, x5i, x7r, x7i, x8r, x8i, x10r, x10i, 
+        x11r, x11i, x12r, x12i, x13r, x13i, x14r, x14i;
+    
+    x1r = a[2];
+    x1i = a[3];
+    x2r = a[4];
+    x2i = a[5];
+    x3r = a[6];
+    x3i = a[7];
+    x4r = a[8];
+    x4i = a[9];
+    x5r = a[10];
+    x5i = a[11];
+    x7r = a[14];
+    x7i = a[15];
+    x8r = a[16];
+    x8i = a[17];
+    x10r = a[20];
+    x10i = a[21];
+    x11r = a[22];
+    x11i = a[23];
+    x12r = a[24];
+    x12i = a[25];
+    x13r = a[26];
+    x13i = a[27];
+    x14r = a[28];
+    x14i = a[29];
+    a[2] = x8r;
+    a[3] = x8i;
+    a[4] = x4r;
+    a[5] = x4i;
+    a[6] = x12r;
+    a[7] = x12i;
+    a[8] = x2r;
+    a[9] = x2i;
+    a[10] = x10r;
+    a[11] = x10i;
+    a[14] = x14r;
+    a[15] = x14i;
+    a[16] = x1r;
+    a[17] = x1i;
+    a[20] = x5r;
+    a[21] = x5i;
+    a[22] = x13r;
+    a[23] = x13i;
+    a[24] = x3r;
+    a[25] = x3i;
+    a[26] = x11r;
+    a[27] = x11i;
+    a[28] = x7r;
+    a[29] = x7i;
+}
+
+
+void bitrv216neg(double *a)
+{
+    double x1r, x1i, x2r, x2i, x3r, x3i, x4r, x4i, 
+        x5r, x5i, x6r, x6i, x7r, x7i, x8r, x8i, 
+        x9r, x9i, x10r, x10i, x11r, x11i, x12r, x12i, 
+        x13r, x13i, x14r, x14i, x15r, x15i;
+    
+    x1r = a[2];
+    x1i = a[3];
+    x2r = a[4];
+    x2i = a[5];
+    x3r = a[6];
+    x3i = a[7];
+    x4r = a[8];
+    x4i = a[9];
+    x5r = a[10];
+    x5i = a[11];
+    x6r = a[12];
+    x6i = a[13];
+    x7r = a[14];
+    x7i = a[15];
+    x8r = a[16];
+    x8i = a[17];
+    x9r = a[18];
+    x9i = a[19];
+    x10r = a[20];
+    x10i = a[21];
+    x11r = a[22];
+    x11i = a[23];
+    x12r = a[24];
+    x12i = a[25];
+    x13r = a[26];
+    x13i = a[27];
+    x14r = a[28];
+    x14i = a[29];
+    x15r = a[30];
+    x15i = a[31];
+    a[2] = x15r;
+    a[3] = x15i;
+    a[4] = x7r;
+    a[5] = x7i;
+    a[6] = x11r;
+    a[7] = x11i;
+    a[8] = x3r;
+    a[9] = x3i;
+    a[10] = x13r;
+    a[11] = x13i;
+    a[12] = x5r;
+    a[13] = x5i;
+    a[14] = x9r;
+    a[15] = x9i;
+    a[16] = x1r;
+    a[17] = x1i;
+    a[18] = x14r;
+    a[19] = x14i;
+    a[20] = x6r;
+    a[21] = x6i;
+    a[22] = x10r;
+    a[23] = x10i;
+    a[24] = x2r;
+    a[25] = x2i;
+    a[26] = x12r;
+    a[27] = x12i;
+    a[28] = x4r;
+    a[29] = x4i;
+    a[30] = x8r;
+    a[31] = x8i;
+}
+
+
+void bitrv208(double *a)
+{
+    double x1r, x1i, x3r, x3i, x4r, x4i, x6r, x6i;
+    
+    x1r = a[2];
+    x1i = a[3];
+    x3r = a[6];
+    x3i = a[7];
+    x4r = a[8];
+    x4i = a[9];
+    x6r = a[12];
+    x6i = a[13];
+    a[2] = x4r;
+    a[3] = x4i;
+    a[6] = x6r;
+    a[7] = x6i;
+    a[8] = x1r;
+    a[9] = x1i;
+    a[12] = x3r;
+    a[13] = x3i;
+}
+
+
+void bitrv208neg(double *a)
+{
+    double x1r, x1i, x2r, x2i, x3r, x3i, x4r, x4i, 
+        x5r, x5i, x6r, x6i, x7r, x7i;
+    
+    x1r = a[2];
+    x1i = a[3];
+    x2r = a[4];
+    x2i = a[5];
+    x3r = a[6];
+    x3i = a[7];
+    x4r = a[8];
+    x4i = a[9];
+    x5r = a[10];
+    x5i = a[11];
+    x6r = a[12];
+    x6i = a[13];
+    x7r = a[14];
+    x7i = a[15];
+    a[2] = x7r;
+    a[3] = x7i;
+    a[4] = x3r;
+    a[5] = x3i;
+    a[6] = x5r;
+    a[7] = x5i;
+    a[8] = x1r;
+    a[9] = x1i;
+    a[10] = x6r;
+    a[11] = x6i;
+    a[12] = x2r;
+    a[13] = x2i;
+    a[14] = x4r;
+    a[15] = x4i;
+}
+
+
+void cftf1st(int n, double *a, double *w)
+{
+    int j, j0, j1, j2, j3, k, m, mh;
+    double wn4r, csc1, csc3, wk1r, wk1i, wk3r, wk3i, 
+        wd1r, wd1i, wd3r, wd3i;
+    double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, 
+        y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i;
+    
+    mh = n >> 3;
+    m = 2 * mh;
+    j1 = m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[0] + a[j2];
+    x0i = a[1] + a[j2 + 1];
+    x1r = a[0] - a[j2];
+    x1i = a[1] - a[j2 + 1];
+    x2r = a[j1] + a[j3];
+    x2i = a[j1 + 1] + a[j3 + 1];
+    x3r = a[j1] - a[j3];
+    x3i = a[j1 + 1] - a[j3 + 1];
+    a[0] = x0r + x2r;
+    a[1] = x0i + x2i;
+    a[j1] = x0r - x2r;
+    a[j1 + 1] = x0i - x2i;
+    a[j2] = x1r - x3i;
+    a[j2 + 1] = x1i + x3r;
+    a[j3] = x1r + x3i;
+    a[j3 + 1] = x1i - x3r;
+    wn4r = w[1];
+    csc1 = w[2];
+    csc3 = w[3];
+    wd1r = 1;
+    wd1i = 0;
+    wd3r = 1;
+    wd3i = 0;
+    k = 0;
+    for (j = 2; j < mh - 2; j += 4) {
+        k += 4;
+        wk1r = csc1 * (wd1r + w[k]);
+        wk1i = csc1 * (wd1i + w[k + 1]);
+        wk3r = csc3 * (wd3r + w[k + 2]);
+        wk3i = csc3 * (wd3i + w[k + 3]);
+        wd1r = w[k];
+        wd1i = w[k + 1];
+        wd3r = w[k + 2];
+        wd3i = w[k + 3];
+        j1 = j + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j] + a[j2];
+        x0i = a[j + 1] + a[j2 + 1];
+        x1r = a[j] - a[j2];
+        x1i = a[j + 1] - a[j2 + 1];
+        y0r = a[j + 2] + a[j2 + 2];
+        y0i = a[j + 3] + a[j2 + 3];
+        y1r = a[j + 2] - a[j2 + 2];
+        y1i = a[j + 3] - a[j2 + 3];
+        x2r = a[j1] + a[j3];
+        x2i = a[j1 + 1] + a[j3 + 1];
+        x3r = a[j1] - a[j3];
+        x3i = a[j1 + 1] - a[j3 + 1];
+        y2r = a[j1 + 2] + a[j3 + 2];
+        y2i = a[j1 + 3] + a[j3 + 3];
+        y3r = a[j1 + 2] - a[j3 + 2];
+        y3i = a[j1 + 3] - a[j3 + 3];
+        a[j] = x0r + x2r;
+        a[j + 1] = x0i + x2i;
+        a[j + 2] = y0r + y2r;
+        a[j + 3] = y0i + y2i;
+        a[j1] = x0r - x2r;
+        a[j1 + 1] = x0i - x2i;
+        a[j1 + 2] = y0r - y2r;
+        a[j1 + 3] = y0i - y2i;
+        x0r = x1r - x3i;
+        x0i = x1i + x3r;
+        a[j2] = wk1r * x0r - wk1i * x0i;
+        a[j2 + 1] = wk1r * x0i + wk1i * x0r;
+        x0r = y1r - y3i;
+        x0i = y1i + y3r;
+        a[j2 + 2] = wd1r * x0r - wd1i * x0i;
+        a[j2 + 3] = wd1r * x0i + wd1i * x0r;
+        x0r = x1r + x3i;
+        x0i = x1i - x3r;
+        a[j3] = wk3r * x0r + wk3i * x0i;
+        a[j3 + 1] = wk3r * x0i - wk3i * x0r;
+        x0r = y1r + y3i;
+        x0i = y1i - y3r;
+        a[j3 + 2] = wd3r * x0r + wd3i * x0i;
+        a[j3 + 3] = wd3r * x0i - wd3i * x0r;
+        j0 = m - j;
+        j1 = j0 + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j0] + a[j2];
+        x0i = a[j0 + 1] + a[j2 + 1];
+        x1r = a[j0] - a[j2];
+        x1i = a[j0 + 1] - a[j2 + 1];
+        y0r = a[j0 - 2] + a[j2 - 2];
+        y0i = a[j0 - 1] + a[j2 - 1];
+        y1r = a[j0 - 2] - a[j2 - 2];
+        y1i = a[j0 - 1] - a[j2 - 1];
+        x2r = a[j1] + a[j3];
+        x2i = a[j1 + 1] + a[j3 + 1];
+        x3r = a[j1] - a[j3];
+        x3i = a[j1 + 1] - a[j3 + 1];
+        y2r = a[j1 - 2] + a[j3 - 2];
+        y2i = a[j1 - 1] + a[j3 - 1];
+        y3r = a[j1 - 2] - a[j3 - 2];
+        y3i = a[j1 - 1] - a[j3 - 1];
+        a[j0] = x0r + x2r;
+        a[j0 + 1] = x0i + x2i;
+        a[j0 - 2] = y0r + y2r;
+        a[j0 - 1] = y0i + y2i;
+        a[j1] = x0r - x2r;
+        a[j1 + 1] = x0i - x2i;
+        a[j1 - 2] = y0r - y2r;
+        a[j1 - 1] = y0i - y2i;
+        x0r = x1r - x3i;
+        x0i = x1i + x3r;
+        a[j2] = wk1i * x0r - wk1r * x0i;
+        a[j2 + 1] = wk1i * x0i + wk1r * x0r;
+        x0r = y1r - y3i;
+        x0i = y1i + y3r;
+        a[j2 - 2] = wd1i * x0r - wd1r * x0i;
+        a[j2 - 1] = wd1i * x0i + wd1r * x0r;
+        x0r = x1r + x3i;
+        x0i = x1i - x3r;
+        a[j3] = wk3i * x0r + wk3r * x0i;
+        a[j3 + 1] = wk3i * x0i - wk3r * x0r;
+        x0r = y1r + y3i;
+        x0i = y1i - y3r;
+        a[j3 - 2] = wd3i * x0r + wd3r * x0i;
+        a[j3 - 1] = wd3i * x0i - wd3r * x0r;
+    }
+    wk1r = csc1 * (wd1r + wn4r);
+    wk1i = csc1 * (wd1i + wn4r);
+    wk3r = csc3 * (wd3r - wn4r);
+    wk3i = csc3 * (wd3i - wn4r);
+    j0 = mh;
+    j1 = j0 + m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[j0 - 2] + a[j2 - 2];
+    x0i = a[j0 - 1] + a[j2 - 1];
+    x1r = a[j0 - 2] - a[j2 - 2];
+    x1i = a[j0 - 1] - a[j2 - 1];
+    x2r = a[j1 - 2] + a[j3 - 2];
+    x2i = a[j1 - 1] + a[j3 - 1];
+    x3r = a[j1 - 2] - a[j3 - 2];
+    x3i = a[j1 - 1] - a[j3 - 1];
+    a[j0 - 2] = x0r + x2r;
+    a[j0 - 1] = x0i + x2i;
+    a[j1 - 2] = x0r - x2r;
+    a[j1 - 1] = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    a[j2 - 2] = wk1r * x0r - wk1i * x0i;
+    a[j2 - 1] = wk1r * x0i + wk1i * x0r;
+    x0r = x1r + x3i;
+    x0i = x1i - x3r;
+    a[j3 - 2] = wk3r * x0r + wk3i * x0i;
+    a[j3 - 1] = wk3r * x0i - wk3i * x0r;
+    x0r = a[j0] + a[j2];
+    x0i = a[j0 + 1] + a[j2 + 1];
+    x1r = a[j0] - a[j2];
+    x1i = a[j0 + 1] - a[j2 + 1];
+    x2r = a[j1] + a[j3];
+    x2i = a[j1 + 1] + a[j3 + 1];
+    x3r = a[j1] - a[j3];
+    x3i = a[j1 + 1] - a[j3 + 1];
+    a[j0] = x0r + x2r;
+    a[j0 + 1] = x0i + x2i;
+    a[j1] = x0r - x2r;
+    a[j1 + 1] = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    a[j2] = wn4r * (x0r - x0i);
+    a[j2 + 1] = wn4r * (x0i + x0r);
+    x0r = x1r + x3i;
+    x0i = x1i - x3r;
+    a[j3] = -wn4r * (x0r + x0i);
+    a[j3 + 1] = -wn4r * (x0i - x0r);
+    x0r = a[j0 + 2] + a[j2 + 2];
+    x0i = a[j0 + 3] + a[j2 + 3];
+    x1r = a[j0 + 2] - a[j2 + 2];
+    x1i = a[j0 + 3] - a[j2 + 3];
+    x2r = a[j1 + 2] + a[j3 + 2];
+    x2i = a[j1 + 3] + a[j3 + 3];
+    x3r = a[j1 + 2] - a[j3 + 2];
+    x3i = a[j1 + 3] - a[j3 + 3];
+    a[j0 + 2] = x0r + x2r;
+    a[j0 + 3] = x0i + x2i;
+    a[j1 + 2] = x0r - x2r;
+    a[j1 + 3] = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    a[j2 + 2] = wk1i * x0r - wk1r * x0i;
+    a[j2 + 3] = wk1i * x0i + wk1r * x0r;
+    x0r = x1r + x3i;
+    x0i = x1i - x3r;
+    a[j3 + 2] = wk3i * x0r + wk3r * x0i;
+    a[j3 + 3] = wk3i * x0i - wk3r * x0r;
+}
+
+
+void cftb1st(int n, double *a, double *w)
+{
+    int j, j0, j1, j2, j3, k, m, mh;
+    double wn4r, csc1, csc3, wk1r, wk1i, wk3r, wk3i, 
+        wd1r, wd1i, wd3r, wd3i;
+    double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, 
+        y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i;
+    
+    mh = n >> 3;
+    m = 2 * mh;
+    j1 = m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[0] + a[j2];
+    x0i = -a[1] - a[j2 + 1];
+    x1r = a[0] - a[j2];
+    x1i = -a[1] + a[j2 + 1];
+    x2r = a[j1] + a[j3];
+    x2i = a[j1 + 1] + a[j3 + 1];
+    x3r = a[j1] - a[j3];
+    x3i = a[j1 + 1] - a[j3 + 1];
+    a[0] = x0r + x2r;
+    a[1] = x0i - x2i;
+    a[j1] = x0r - x2r;
+    a[j1 + 1] = x0i + x2i;
+    a[j2] = x1r + x3i;
+    a[j2 + 1] = x1i + x3r;
+    a[j3] = x1r - x3i;
+    a[j3 + 1] = x1i - x3r;
+    wn4r = w[1];
+    csc1 = w[2];
+    csc3 = w[3];
+    wd1r = 1;
+    wd1i = 0;
+    wd3r = 1;
+    wd3i = 0;
+    k = 0;
+    for (j = 2; j < mh - 2; j += 4) {
+        k += 4;
+        wk1r = csc1 * (wd1r + w[k]);
+        wk1i = csc1 * (wd1i + w[k + 1]);
+        wk3r = csc3 * (wd3r + w[k + 2]);
+        wk3i = csc3 * (wd3i + w[k + 3]);
+        wd1r = w[k];
+        wd1i = w[k + 1];
+        wd3r = w[k + 2];
+        wd3i = w[k + 3];
+        j1 = j + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j] + a[j2];
+        x0i = -a[j + 1] - a[j2 + 1];
+        x1r = a[j] - a[j2];
+        x1i = -a[j + 1] + a[j2 + 1];
+        y0r = a[j + 2] + a[j2 + 2];
+        y0i = -a[j + 3] - a[j2 + 3];
+        y1r = a[j + 2] - a[j2 + 2];
+        y1i = -a[j + 3] + a[j2 + 3];
+        x2r = a[j1] + a[j3];
+        x2i = a[j1 + 1] + a[j3 + 1];
+        x3r = a[j1] - a[j3];
+        x3i = a[j1 + 1] - a[j3 + 1];
+        y2r = a[j1 + 2] + a[j3 + 2];
+        y2i = a[j1 + 3] + a[j3 + 3];
+        y3r = a[j1 + 2] - a[j3 + 2];
+        y3i = a[j1 + 3] - a[j3 + 3];
+        a[j] = x0r + x2r;
+        a[j + 1] = x0i - x2i;
+        a[j + 2] = y0r + y2r;
+        a[j + 3] = y0i - y2i;
+        a[j1] = x0r - x2r;
+        a[j1 + 1] = x0i + x2i;
+        a[j1 + 2] = y0r - y2r;
+        a[j1 + 3] = y0i + y2i;
+        x0r = x1r + x3i;
+        x0i = x1i + x3r;
+        a[j2] = wk1r * x0r - wk1i * x0i;
+        a[j2 + 1] = wk1r * x0i + wk1i * x0r;
+        x0r = y1r + y3i;
+        x0i = y1i + y3r;
+        a[j2 + 2] = wd1r * x0r - wd1i * x0i;
+        a[j2 + 3] = wd1r * x0i + wd1i * x0r;
+        x0r = x1r - x3i;
+        x0i = x1i - x3r;
+        a[j3] = wk3r * x0r + wk3i * x0i;
+        a[j3 + 1] = wk3r * x0i - wk3i * x0r;
+        x0r = y1r - y3i;
+        x0i = y1i - y3r;
+        a[j3 + 2] = wd3r * x0r + wd3i * x0i;
+        a[j3 + 3] = wd3r * x0i - wd3i * x0r;
+        j0 = m - j;
+        j1 = j0 + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j0] + a[j2];
+        x0i = -a[j0 + 1] - a[j2 + 1];
+        x1r = a[j0] - a[j2];
+        x1i = -a[j0 + 1] + a[j2 + 1];
+        y0r = a[j0 - 2] + a[j2 - 2];
+        y0i = -a[j0 - 1] - a[j2 - 1];
+        y1r = a[j0 - 2] - a[j2 - 2];
+        y1i = -a[j0 - 1] + a[j2 - 1];
+        x2r = a[j1] + a[j3];
+        x2i = a[j1 + 1] + a[j3 + 1];
+        x3r = a[j1] - a[j3];
+        x3i = a[j1 + 1] - a[j3 + 1];
+        y2r = a[j1 - 2] + a[j3 - 2];
+        y2i = a[j1 - 1] + a[j3 - 1];
+        y3r = a[j1 - 2] - a[j3 - 2];
+        y3i = a[j1 - 1] - a[j3 - 1];
+        a[j0] = x0r + x2r;
+        a[j0 + 1] = x0i - x2i;
+        a[j0 - 2] = y0r + y2r;
+        a[j0 - 1] = y0i - y2i;
+        a[j1] = x0r - x2r;
+        a[j1 + 1] = x0i + x2i;
+        a[j1 - 2] = y0r - y2r;
+        a[j1 - 1] = y0i + y2i;
+        x0r = x1r + x3i;
+        x0i = x1i + x3r;
+        a[j2] = wk1i * x0r - wk1r * x0i;
+        a[j2 + 1] = wk1i * x0i + wk1r * x0r;
+        x0r = y1r + y3i;
+        x0i = y1i + y3r;
+        a[j2 - 2] = wd1i * x0r - wd1r * x0i;
+        a[j2 - 1] = wd1i * x0i + wd1r * x0r;
+        x0r = x1r - x3i;
+        x0i = x1i - x3r;
+        a[j3] = wk3i * x0r + wk3r * x0i;
+        a[j3 + 1] = wk3i * x0i - wk3r * x0r;
+        x0r = y1r - y3i;
+        x0i = y1i - y3r;
+        a[j3 - 2] = wd3i * x0r + wd3r * x0i;
+        a[j3 - 1] = wd3i * x0i - wd3r * x0r;
+    }
+    wk1r = csc1 * (wd1r + wn4r);
+    wk1i = csc1 * (wd1i + wn4r);
+    wk3r = csc3 * (wd3r - wn4r);
+    wk3i = csc3 * (wd3i - wn4r);
+    j0 = mh;
+    j1 = j0 + m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[j0 - 2] + a[j2 - 2];
+    x0i = -a[j0 - 1] - a[j2 - 1];
+    x1r = a[j0 - 2] - a[j2 - 2];
+    x1i = -a[j0 - 1] + a[j2 - 1];
+    x2r = a[j1 - 2] + a[j3 - 2];
+    x2i = a[j1 - 1] + a[j3 - 1];
+    x3r = a[j1 - 2] - a[j3 - 2];
+    x3i = a[j1 - 1] - a[j3 - 1];
+    a[j0 - 2] = x0r + x2r;
+    a[j0 - 1] = x0i - x2i;
+    a[j1 - 2] = x0r - x2r;
+    a[j1 - 1] = x0i + x2i;
+    x0r = x1r + x3i;
+    x0i = x1i + x3r;
+    a[j2 - 2] = wk1r * x0r - wk1i * x0i;
+    a[j2 - 1] = wk1r * x0i + wk1i * x0r;
+    x0r = x1r - x3i;
+    x0i = x1i - x3r;
+    a[j3 - 2] = wk3r * x0r + wk3i * x0i;
+    a[j3 - 1] = wk3r * x0i - wk3i * x0r;
+    x0r = a[j0] + a[j2];
+    x0i = -a[j0 + 1] - a[j2 + 1];
+    x1r = a[j0] - a[j2];
+    x1i = -a[j0 + 1] + a[j2 + 1];
+    x2r = a[j1] + a[j3];
+    x2i = a[j1 + 1] + a[j3 + 1];
+    x3r = a[j1] - a[j3];
+    x3i = a[j1 + 1] - a[j3 + 1];
+    a[j0] = x0r + x2r;
+    a[j0 + 1] = x0i - x2i;
+    a[j1] = x0r - x2r;
+    a[j1 + 1] = x0i + x2i;
+    x0r = x1r + x3i;
+    x0i = x1i + x3r;
+    a[j2] = wn4r * (x0r - x0i);
+    a[j2 + 1] = wn4r * (x0i + x0r);
+    x0r = x1r - x3i;
+    x0i = x1i - x3r;
+    a[j3] = -wn4r * (x0r + x0i);
+    a[j3 + 1] = -wn4r * (x0i - x0r);
+    x0r = a[j0 + 2] + a[j2 + 2];
+    x0i = -a[j0 + 3] - a[j2 + 3];
+    x1r = a[j0 + 2] - a[j2 + 2];
+    x1i = -a[j0 + 3] + a[j2 + 3];
+    x2r = a[j1 + 2] + a[j3 + 2];
+    x2i = a[j1 + 3] + a[j3 + 3];
+    x3r = a[j1 + 2] - a[j3 + 2];
+    x3i = a[j1 + 3] - a[j3 + 3];
+    a[j0 + 2] = x0r + x2r;
+    a[j0 + 3] = x0i - x2i;
+    a[j1 + 2] = x0r - x2r;
+    a[j1 + 3] = x0i + x2i;
+    x0r = x1r + x3i;
+    x0i = x1i + x3r;
+    a[j2 + 2] = wk1i * x0r - wk1r * x0i;
+    a[j2 + 3] = wk1i * x0i + wk1r * x0r;
+    x0r = x1r - x3i;
+    x0i = x1i - x3r;
+    a[j3 + 2] = wk3i * x0r + wk3r * x0i;
+    a[j3 + 3] = wk3i * x0i - wk3r * x0r;
+}
+
+
+#ifdef USE_CDFT_THREADS
+struct cdft_arg_st {
+    int n0;
+    int n;
+    double *a;
+    int nw;
+    double *w;
+};
+typedef struct cdft_arg_st cdft_arg_t;
+
+
+void cftrec4_th(int n, double *a, int nw, double *w)
+{
+    void *cftrec1_th(void *p);
+    void *cftrec2_th(void *p);
+    int i, idiv4, m, nthread;
+    cdft_thread_t th[4];
+    cdft_arg_t ag[4];
+    
+    nthread = 2;
+    idiv4 = 0;
+    m = n >> 1;
+    if (n > CDFT_4THREADS_BEGIN_N) {
+        nthread = 4;
+        idiv4 = 1;
+        m >>= 1;
+    }
+    for (i = 0; i < nthread; i++) {
+        ag[i].n0 = n;
+        ag[i].n = m;
+        ag[i].a = &a[i * m];
+        ag[i].nw = nw;
+        ag[i].w = w;
+        if (i != idiv4) {
+            cdft_thread_create(&th[i], cftrec1_th, &ag[i]);
+        } else {
+            cdft_thread_create(&th[i], cftrec2_th, &ag[i]);
+        }
+    }
+    for (i = 0; i < nthread; i++) {
+        cdft_thread_wait(th[i]);
+    }
+}
+
+
+void *cftrec1_th(void *p)
+{
+    int cfttree(int n, int j, int k, double *a, int nw, double *w);
+    void cftleaf(int n, int isplt, double *a, int nw, double *w);
+    void cftmdl1(int n, double *a, double *w);
+    int isplt, j, k, m, n, n0, nw;
+    double *a, *w;
+    
+    n0 = ((cdft_arg_t *) p)->n0;
+    n = ((cdft_arg_t *) p)->n;
+    a = ((cdft_arg_t *) p)->a;
+    nw = ((cdft_arg_t *) p)->nw;
+    w = ((cdft_arg_t *) p)->w;
+    m = n0;
+    while (m > 512) {
+        m >>= 2;
+        cftmdl1(m, &a[n - m], &w[nw - (m >> 1)]);
+    }
+    cftleaf(m, 1, &a[n - m], nw, w);
+    k = 0;
+    for (j = n - m; j > 0; j -= m) {
+        k++;
+        isplt = cfttree(m, j, k, a, nw, w);
+        cftleaf(m, isplt, &a[j - m], nw, w);
+    }
+    return (void *) 0;
+}
+
+
+void *cftrec2_th(void *p)
+{
+    int cfttree(int n, int j, int k, double *a, int nw, double *w);
+    void cftleaf(int n, int isplt, double *a, int nw, double *w);
+    void cftmdl2(int n, double *a, double *w);
+    int isplt, j, k, m, n, n0, nw;
+    double *a, *w;
+    
+    n0 = ((cdft_arg_t *) p)->n0;
+    n = ((cdft_arg_t *) p)->n;
+    a = ((cdft_arg_t *) p)->a;
+    nw = ((cdft_arg_t *) p)->nw;
+    w = ((cdft_arg_t *) p)->w;
+    k = 1;
+    m = n0;
+    while (m > 512) {
+        m >>= 2;
+        k <<= 2;
+        cftmdl2(m, &a[n - m], &w[nw - m]);
+    }
+    cftleaf(m, 0, &a[n - m], nw, w);
+    k >>= 1;
+    for (j = n - m; j > 0; j -= m) {
+        k++;
+        isplt = cfttree(m, j, k, a, nw, w);
+        cftleaf(m, isplt, &a[j - m], nw, w);
+    }
+    return (void *) 0;
+}
+#endif /* USE_CDFT_THREADS */
+
+
+void cftrec4(int n, double *a, int nw, double *w)
+{
+    int cfttree(int n, int j, int k, double *a, int nw, double *w);
+    void cftleaf(int n, int isplt, double *a, int nw, double *w);
+    void cftmdl1(int n, double *a, double *w);
+    int isplt, j, k, m;
+    
+    m = n;
+    while (m > 512) {
+        m >>= 2;
+        cftmdl1(m, &a[n - m], &w[nw - (m >> 1)]);
+    }
+    cftleaf(m, 1, &a[n - m], nw, w);
+    k = 0;
+    for (j = n - m; j > 0; j -= m) {
+        k++;
+        isplt = cfttree(m, j, k, a, nw, w);
+        cftleaf(m, isplt, &a[j - m], nw, w);
+    }
+}
+
+
+int cfttree(int n, int j, int k, double *a, int nw, double *w)
+{
+    void cftmdl1(int n, double *a, double *w);
+    void cftmdl2(int n, double *a, double *w);
+    int i, isplt, m;
+    
+    if ((k & 3) != 0) {
+        isplt = k & 1;
+        if (isplt != 0) {
+            cftmdl1(n, &a[j - n], &w[nw - (n >> 1)]);
+        } else {
+            cftmdl2(n, &a[j - n], &w[nw - n]);
+        }
+    } else {
+        m = n;
+        for (i = k; (i & 3) == 0; i >>= 2) {
+            m <<= 2;
+        }
+        isplt = i & 1;
+        if (isplt != 0) {
+            while (m > 128) {
+                cftmdl1(m, &a[j - m], &w[nw - (m >> 1)]);
+                m >>= 2;
+            }
+        } else {
+            while (m > 128) {
+                cftmdl2(m, &a[j - m], &w[nw - m]);
+                m >>= 2;
+            }
+        }
+    }
+    return isplt;
+}
+
+
+void cftleaf(int n, int isplt, double *a, int nw, double *w)
+{
+    void cftmdl1(int n, double *a, double *w);
+    void cftmdl2(int n, double *a, double *w);
+    void cftf161(double *a, double *w);
+    void cftf162(double *a, double *w);
+    void cftf081(double *a, double *w);
+    void cftf082(double *a, double *w);
+    
+    if (n == 512) {
+        cftmdl1(128, a, &w[nw - 64]);
+        cftf161(a, &w[nw - 8]);
+        cftf162(&a[32], &w[nw - 32]);
+        cftf161(&a[64], &w[nw - 8]);
+        cftf161(&a[96], &w[nw - 8]);
+        cftmdl2(128, &a[128], &w[nw - 128]);
+        cftf161(&a[128], &w[nw - 8]);
+        cftf162(&a[160], &w[nw - 32]);
+        cftf161(&a[192], &w[nw - 8]);
+        cftf162(&a[224], &w[nw - 32]);
+        cftmdl1(128, &a[256], &w[nw - 64]);
+        cftf161(&a[256], &w[nw - 8]);
+        cftf162(&a[288], &w[nw - 32]);
+        cftf161(&a[320], &w[nw - 8]);
+        cftf161(&a[352], &w[nw - 8]);
+        if (isplt != 0) {
+            cftmdl1(128, &a[384], &w[nw - 64]);
+            cftf161(&a[480], &w[nw - 8]);
+        } else {
+            cftmdl2(128, &a[384], &w[nw - 128]);
+            cftf162(&a[480], &w[nw - 32]);
+        }
+        cftf161(&a[384], &w[nw - 8]);
+        cftf162(&a[416], &w[nw - 32]);
+        cftf161(&a[448], &w[nw - 8]);
+    } else {
+        cftmdl1(64, a, &w[nw - 32]);
+        cftf081(a, &w[nw - 8]);
+        cftf082(&a[16], &w[nw - 8]);
+        cftf081(&a[32], &w[nw - 8]);
+        cftf081(&a[48], &w[nw - 8]);
+        cftmdl2(64, &a[64], &w[nw - 64]);
+        cftf081(&a[64], &w[nw - 8]);
+        cftf082(&a[80], &w[nw - 8]);
+        cftf081(&a[96], &w[nw - 8]);
+        cftf082(&a[112], &w[nw - 8]);
+        cftmdl1(64, &a[128], &w[nw - 32]);
+        cftf081(&a[128], &w[nw - 8]);
+        cftf082(&a[144], &w[nw - 8]);
+        cftf081(&a[160], &w[nw - 8]);
+        cftf081(&a[176], &w[nw - 8]);
+        if (isplt != 0) {
+            cftmdl1(64, &a[192], &w[nw - 32]);
+            cftf081(&a[240], &w[nw - 8]);
+        } else {
+            cftmdl2(64, &a[192], &w[nw - 64]);
+            cftf082(&a[240], &w[nw - 8]);
+        }
+        cftf081(&a[192], &w[nw - 8]);
+        cftf082(&a[208], &w[nw - 8]);
+        cftf081(&a[224], &w[nw - 8]);
+    }
+}
+
+
+void cftmdl1(int n, double *a, double *w)
+{
+    int j, j0, j1, j2, j3, k, m, mh;
+    double wn4r, wk1r, wk1i, wk3r, wk3i;
+    double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+    
+    mh = n >> 3;
+    m = 2 * mh;
+    j1 = m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[0] + a[j2];
+    x0i = a[1] + a[j2 + 1];
+    x1r = a[0] - a[j2];
+    x1i = a[1] - a[j2 + 1];
+    x2r = a[j1] + a[j3];
+    x2i = a[j1 + 1] + a[j3 + 1];
+    x3r = a[j1] - a[j3];
+    x3i = a[j1 + 1] - a[j3 + 1];
+    a[0] = x0r + x2r;
+    a[1] = x0i + x2i;
+    a[j1] = x0r - x2r;
+    a[j1 + 1] = x0i - x2i;
+    a[j2] = x1r - x3i;
+    a[j2 + 1] = x1i + x3r;
+    a[j3] = x1r + x3i;
+    a[j3 + 1] = x1i - x3r;
+    wn4r = w[1];
+    k = 0;
+    for (j = 2; j < mh; j += 2) {
+        k += 4;
+        wk1r = w[k];
+        wk1i = w[k + 1];
+        wk3r = w[k + 2];
+        wk3i = w[k + 3];
+        j1 = j + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j] + a[j2];
+        x0i = a[j + 1] + a[j2 + 1];
+        x1r = a[j] - a[j2];
+        x1i = a[j + 1] - a[j2 + 1];
+        x2r = a[j1] + a[j3];
+        x2i = a[j1 + 1] + a[j3 + 1];
+        x3r = a[j1] - a[j3];
+        x3i = a[j1 + 1] - a[j3 + 1];
+        a[j] = x0r + x2r;
+        a[j + 1] = x0i + x2i;
+        a[j1] = x0r - x2r;
+        a[j1 + 1] = x0i - x2i;
+        x0r = x1r - x3i;
+        x0i = x1i + x3r;
+        a[j2] = wk1r * x0r - wk1i * x0i;
+        a[j2 + 1] = wk1r * x0i + wk1i * x0r;
+        x0r = x1r + x3i;
+        x0i = x1i - x3r;
+        a[j3] = wk3r * x0r + wk3i * x0i;
+        a[j3 + 1] = wk3r * x0i - wk3i * x0r;
+        j0 = m - j;
+        j1 = j0 + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j0] + a[j2];
+        x0i = a[j0 + 1] + a[j2 + 1];
+        x1r = a[j0] - a[j2];
+        x1i = a[j0 + 1] - a[j2 + 1];
+        x2r = a[j1] + a[j3];
+        x2i = a[j1 + 1] + a[j3 + 1];
+        x3r = a[j1] - a[j3];
+        x3i = a[j1 + 1] - a[j3 + 1];
+        a[j0] = x0r + x2r;
+        a[j0 + 1] = x0i + x2i;
+        a[j1] = x0r - x2r;
+        a[j1 + 1] = x0i - x2i;
+        x0r = x1r - x3i;
+        x0i = x1i + x3r;
+        a[j2] = wk1i * x0r - wk1r * x0i;
+        a[j2 + 1] = wk1i * x0i + wk1r * x0r;
+        x0r = x1r + x3i;
+        x0i = x1i - x3r;
+        a[j3] = wk3i * x0r + wk3r * x0i;
+        a[j3 + 1] = wk3i * x0i - wk3r * x0r;
+    }
+    j0 = mh;
+    j1 = j0 + m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[j0] + a[j2];
+    x0i = a[j0 + 1] + a[j2 + 1];
+    x1r = a[j0] - a[j2];
+    x1i = a[j0 + 1] - a[j2 + 1];
+    x2r = a[j1] + a[j3];
+    x2i = a[j1 + 1] + a[j3 + 1];
+    x3r = a[j1] - a[j3];
+    x3i = a[j1 + 1] - a[j3 + 1];
+    a[j0] = x0r + x2r;
+    a[j0 + 1] = x0i + x2i;
+    a[j1] = x0r - x2r;
+    a[j1 + 1] = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    a[j2] = wn4r * (x0r - x0i);
+    a[j2 + 1] = wn4r * (x0i + x0r);
+    x0r = x1r + x3i;
+    x0i = x1i - x3r;
+    a[j3] = -wn4r * (x0r + x0i);
+    a[j3 + 1] = -wn4r * (x0i - x0r);
+}
+
+
+void cftmdl2(int n, double *a, double *w)
+{
+    int j, j0, j1, j2, j3, k, kr, m, mh;
+    double wn4r, wk1r, wk1i, wk3r, wk3i, wd1r, wd1i, wd3r, wd3i;
+    double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, y0r, y0i, y2r, y2i;
+    
+    mh = n >> 3;
+    m = 2 * mh;
+    wn4r = w[1];
+    j1 = m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[0] - a[j2 + 1];
+    x0i = a[1] + a[j2];
+    x1r = a[0] + a[j2 + 1];
+    x1i = a[1] - a[j2];
+    x2r = a[j1] - a[j3 + 1];
+    x2i = a[j1 + 1] + a[j3];
+    x3r = a[j1] + a[j3 + 1];
+    x3i = a[j1 + 1] - a[j3];
+    y0r = wn4r * (x2r - x2i);
+    y0i = wn4r * (x2i + x2r);
+    a[0] = x0r + y0r;
+    a[1] = x0i + y0i;
+    a[j1] = x0r - y0r;
+    a[j1 + 1] = x0i - y0i;
+    y0r = wn4r * (x3r - x3i);
+    y0i = wn4r * (x3i + x3r);
+    a[j2] = x1r - y0i;
+    a[j2 + 1] = x1i + y0r;
+    a[j3] = x1r + y0i;
+    a[j3 + 1] = x1i - y0r;
+    k = 0;
+    kr = 2 * m;
+    for (j = 2; j < mh; j += 2) {
+        k += 4;
+        wk1r = w[k];
+        wk1i = w[k + 1];
+        wk3r = w[k + 2];
+        wk3i = w[k + 3];
+        kr -= 4;
+        wd1i = w[kr];
+        wd1r = w[kr + 1];
+        wd3i = w[kr + 2];
+        wd3r = w[kr + 3];
+        j1 = j + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j] - a[j2 + 1];
+        x0i = a[j + 1] + a[j2];
+        x1r = a[j] + a[j2 + 1];
+        x1i = a[j + 1] - a[j2];
+        x2r = a[j1] - a[j3 + 1];
+        x2i = a[j1 + 1] + a[j3];
+        x3r = a[j1] + a[j3 + 1];
+        x3i = a[j1 + 1] - a[j3];
+        y0r = wk1r * x0r - wk1i * x0i;
+        y0i = wk1r * x0i + wk1i * x0r;
+        y2r = wd1r * x2r - wd1i * x2i;
+        y2i = wd1r * x2i + wd1i * x2r;
+        a[j] = y0r + y2r;
+        a[j + 1] = y0i + y2i;
+        a[j1] = y0r - y2r;
+        a[j1 + 1] = y0i - y2i;
+        y0r = wk3r * x1r + wk3i * x1i;
+        y0i = wk3r * x1i - wk3i * x1r;
+        y2r = wd3r * x3r + wd3i * x3i;
+        y2i = wd3r * x3i - wd3i * x3r;
+        a[j2] = y0r + y2r;
+        a[j2 + 1] = y0i + y2i;
+        a[j3] = y0r - y2r;
+        a[j3 + 1] = y0i - y2i;
+        j0 = m - j;
+        j1 = j0 + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j0] - a[j2 + 1];
+        x0i = a[j0 + 1] + a[j2];
+        x1r = a[j0] + a[j2 + 1];
+        x1i = a[j0 + 1] - a[j2];
+        x2r = a[j1] - a[j3 + 1];
+        x2i = a[j1 + 1] + a[j3];
+        x3r = a[j1] + a[j3 + 1];
+        x3i = a[j1 + 1] - a[j3];
+        y0r = wd1i * x0r - wd1r * x0i;
+        y0i = wd1i * x0i + wd1r * x0r;
+        y2r = wk1i * x2r - wk1r * x2i;
+        y2i = wk1i * x2i + wk1r * x2r;
+        a[j0] = y0r + y2r;
+        a[j0 + 1] = y0i + y2i;
+        a[j1] = y0r - y2r;
+        a[j1 + 1] = y0i - y2i;
+        y0r = wd3i * x1r + wd3r * x1i;
+        y0i = wd3i * x1i - wd3r * x1r;
+        y2r = wk3i * x3r + wk3r * x3i;
+        y2i = wk3i * x3i - wk3r * x3r;
+        a[j2] = y0r + y2r;
+        a[j2 + 1] = y0i + y2i;
+        a[j3] = y0r - y2r;
+        a[j3 + 1] = y0i - y2i;
+    }
+    wk1r = w[m];
+    wk1i = w[m + 1];
+    j0 = mh;
+    j1 = j0 + m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[j0] - a[j2 + 1];
+    x0i = a[j0 + 1] + a[j2];
+    x1r = a[j0] + a[j2 + 1];
+    x1i = a[j0 + 1] - a[j2];
+    x2r = a[j1] - a[j3 + 1];
+    x2i = a[j1 + 1] + a[j3];
+    x3r = a[j1] + a[j3 + 1];
+    x3i = a[j1 + 1] - a[j3];
+    y0r = wk1r * x0r - wk1i * x0i;
+    y0i = wk1r * x0i + wk1i * x0r;
+    y2r = wk1i * x2r - wk1r * x2i;
+    y2i = wk1i * x2i + wk1r * x2r;
+    a[j0] = y0r + y2r;
+    a[j0 + 1] = y0i + y2i;
+    a[j1] = y0r - y2r;
+    a[j1 + 1] = y0i - y2i;
+    y0r = wk1i * x1r - wk1r * x1i;
+    y0i = wk1i * x1i + wk1r * x1r;
+    y2r = wk1r * x3r - wk1i * x3i;
+    y2i = wk1r * x3i + wk1i * x3r;
+    a[j2] = y0r - y2r;
+    a[j2 + 1] = y0i - y2i;
+    a[j3] = y0r + y2r;
+    a[j3 + 1] = y0i + y2i;
+}
+
+
+void cftfx41(int n, double *a, int nw, double *w)
+{
+    void cftf161(double *a, double *w);
+    void cftf162(double *a, double *w);
+    void cftf081(double *a, double *w);
+    void cftf082(double *a, double *w);
+    
+    if (n == 128) {
+        cftf161(a, &w[nw - 8]);
+        cftf162(&a[32], &w[nw - 32]);
+        cftf161(&a[64], &w[nw - 8]);
+        cftf161(&a[96], &w[nw - 8]);
+    } else {
+        cftf081(a, &w[nw - 8]);
+        cftf082(&a[16], &w[nw - 8]);
+        cftf081(&a[32], &w[nw - 8]);
+        cftf081(&a[48], &w[nw - 8]);
+    }
+}
+
+
+void cftf161(double *a, double *w)
+{
+    double wn4r, wk1r, wk1i, 
+        x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, 
+        y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i, 
+        y4r, y4i, y5r, y5i, y6r, y6i, y7r, y7i, 
+        y8r, y8i, y9r, y9i, y10r, y10i, y11r, y11i, 
+        y12r, y12i, y13r, y13i, y14r, y14i, y15r, y15i;
+    
+    wn4r = w[1];
+    wk1r = w[2];
+    wk1i = w[3];
+    x0r = a[0] + a[16];
+    x0i = a[1] + a[17];
+    x1r = a[0] - a[16];
+    x1i = a[1] - a[17];
+    x2r = a[8] + a[24];
+    x2i = a[9] + a[25];
+    x3r = a[8] - a[24];
+    x3i = a[9] - a[25];
+    y0r = x0r + x2r;
+    y0i = x0i + x2i;
+    y4r = x0r - x2r;
+    y4i = x0i - x2i;
+    y8r = x1r - x3i;
+    y8i = x1i + x3r;
+    y12r = x1r + x3i;
+    y12i = x1i - x3r;
+    x0r = a[2] + a[18];
+    x0i = a[3] + a[19];
+    x1r = a[2] - a[18];
+    x1i = a[3] - a[19];
+    x2r = a[10] + a[26];
+    x2i = a[11] + a[27];
+    x3r = a[10] - a[26];
+    x3i = a[11] - a[27];
+    y1r = x0r + x2r;
+    y1i = x0i + x2i;
+    y5r = x0r - x2r;
+    y5i = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    y9r = wk1r * x0r - wk1i * x0i;
+    y9i = wk1r * x0i + wk1i * x0r;
+    x0r = x1r + x3i;
+    x0i = x1i - x3r;
+    y13r = wk1i * x0r - wk1r * x0i;
+    y13i = wk1i * x0i + wk1r * x0r;
+    x0r = a[4] + a[20];
+    x0i = a[5] + a[21];
+    x1r = a[4] - a[20];
+    x1i = a[5] - a[21];
+    x2r = a[12] + a[28];
+    x2i = a[13] + a[29];
+    x3r = a[12] - a[28];
+    x3i = a[13] - a[29];
+    y2r = x0r + x2r;
+    y2i = x0i + x2i;
+    y6r = x0r - x2r;
+    y6i = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    y10r = wn4r * (x0r - x0i);
+    y10i = wn4r * (x0i + x0r);
+    x0r = x1r + x3i;
+    x0i = x1i - x3r;
+    y14r = wn4r * (x0r + x0i);
+    y14i = wn4r * (x0i - x0r);
+    x0r = a[6] + a[22];
+    x0i = a[7] + a[23];
+    x1r = a[6] - a[22];
+    x1i = a[7] - a[23];
+    x2r = a[14] + a[30];
+    x2i = a[15] + a[31];
+    x3r = a[14] - a[30];
+    x3i = a[15] - a[31];
+    y3r = x0r + x2r;
+    y3i = x0i + x2i;
+    y7r = x0r - x2r;
+    y7i = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    y11r = wk1i * x0r - wk1r * x0i;
+    y11i = wk1i * x0i + wk1r * x0r;
+    x0r = x1r + x3i;
+    x0i = x1i - x3r;
+    y15r = wk1r * x0r - wk1i * x0i;
+    y15i = wk1r * x0i + wk1i * x0r;
+    x0r = y12r - y14r;
+    x0i = y12i - y14i;
+    x1r = y12r + y14r;
+    x1i = y12i + y14i;
+    x2r = y13r - y15r;
+    x2i = y13i - y15i;
+    x3r = y13r + y15r;
+    x3i = y13i + y15i;
+    a[24] = x0r + x2r;
+    a[25] = x0i + x2i;
+    a[26] = x0r - x2r;
+    a[27] = x0i - x2i;
+    a[28] = x1r - x3i;
+    a[29] = x1i + x3r;
+    a[30] = x1r + x3i;
+    a[31] = x1i - x3r;
+    x0r = y8r + y10r;
+    x0i = y8i + y10i;
+    x1r = y8r - y10r;
+    x1i = y8i - y10i;
+    x2r = y9r + y11r;
+    x2i = y9i + y11i;
+    x3r = y9r - y11r;
+    x3i = y9i - y11i;
+    a[16] = x0r + x2r;
+    a[17] = x0i + x2i;
+    a[18] = x0r - x2r;
+    a[19] = x0i - x2i;
+    a[20] = x1r - x3i;
+    a[21] = x1i + x3r;
+    a[22] = x1r + x3i;
+    a[23] = x1i - x3r;
+    x0r = y5r - y7i;
+    x0i = y5i + y7r;
+    x2r = wn4r * (x0r - x0i);
+    x2i = wn4r * (x0i + x0r);
+    x0r = y5r + y7i;
+    x0i = y5i - y7r;
+    x3r = wn4r * (x0r - x0i);
+    x3i = wn4r * (x0i + x0r);
+    x0r = y4r - y6i;
+    x0i = y4i + y6r;
+    x1r = y4r + y6i;
+    x1i = y4i - y6r;
+    a[8] = x0r + x2r;
+    a[9] = x0i + x2i;
+    a[10] = x0r - x2r;
+    a[11] = x0i - x2i;
+    a[12] = x1r - x3i;
+    a[13] = x1i + x3r;
+    a[14] = x1r + x3i;
+    a[15] = x1i - x3r;
+    x0r = y0r + y2r;
+    x0i = y0i + y2i;
+    x1r = y0r - y2r;
+    x1i = y0i - y2i;
+    x2r = y1r + y3r;
+    x2i = y1i + y3i;
+    x3r = y1r - y3r;
+    x3i = y1i - y3i;
+    a[0] = x0r + x2r;
+    a[1] = x0i + x2i;
+    a[2] = x0r - x2r;
+    a[3] = x0i - x2i;
+    a[4] = x1r - x3i;
+    a[5] = x1i + x3r;
+    a[6] = x1r + x3i;
+    a[7] = x1i - x3r;
+}
+
+
+void cftf162(double *a, double *w)
+{
+    double wn4r, wk1r, wk1i, wk2r, wk2i, wk3r, wk3i, 
+        x0r, x0i, x1r, x1i, x2r, x2i, 
+        y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i, 
+        y4r, y4i, y5r, y5i, y6r, y6i, y7r, y7i, 
+        y8r, y8i, y9r, y9i, y10r, y10i, y11r, y11i, 
+        y12r, y12i, y13r, y13i, y14r, y14i, y15r, y15i;
+    
+    wn4r = w[1];
+    wk1r = w[4];
+    wk1i = w[5];
+    wk3r = w[6];
+    wk3i = -w[7];
+    wk2r = w[8];
+    wk2i = w[9];
+    x1r = a[0] - a[17];
+    x1i = a[1] + a[16];
+    x0r = a[8] - a[25];
+    x0i = a[9] + a[24];
+    x2r = wn4r * (x0r - x0i);
+    x2i = wn4r * (x0i + x0r);
+    y0r = x1r + x2r;
+    y0i = x1i + x2i;
+    y4r = x1r - x2r;
+    y4i = x1i - x2i;
+    x1r = a[0] + a[17];
+    x1i = a[1] - a[16];
+    x0r = a[8] + a[25];
+    x0i = a[9] - a[24];
+    x2r = wn4r * (x0r - x0i);
+    x2i = wn4r * (x0i + x0r);
+    y8r = x1r - x2i;
+    y8i = x1i + x2r;
+    y12r = x1r + x2i;
+    y12i = x1i - x2r;
+    x0r = a[2] - a[19];
+    x0i = a[3] + a[18];
+    x1r = wk1r * x0r - wk1i * x0i;
+    x1i = wk1r * x0i + wk1i * x0r;
+    x0r = a[10] - a[27];
+    x0i = a[11] + a[26];
+    x2r = wk3i * x0r - wk3r * x0i;
+    x2i = wk3i * x0i + wk3r * x0r;
+    y1r = x1r + x2r;
+    y1i = x1i + x2i;
+    y5r = x1r - x2r;
+    y5i = x1i - x2i;
+    x0r = a[2] + a[19];
+    x0i = a[3] - a[18];
+    x1r = wk3r * x0r - wk3i * x0i;
+    x1i = wk3r * x0i + wk3i * x0r;
+    x0r = a[10] + a[27];
+    x0i = a[11] - a[26];
+    x2r = wk1r * x0r + wk1i * x0i;
+    x2i = wk1r * x0i - wk1i * x0r;
+    y9r = x1r - x2r;
+    y9i = x1i - x2i;
+    y13r = x1r + x2r;
+    y13i = x1i + x2i;
+    x0r = a[4] - a[21];
+    x0i = a[5] + a[20];
+    x1r = wk2r * x0r - wk2i * x0i;
+    x1i = wk2r * x0i + wk2i * x0r;
+    x0r = a[12] - a[29];
+    x0i = a[13] + a[28];
+    x2r = wk2i * x0r - wk2r * x0i;
+    x2i = wk2i * x0i + wk2r * x0r;
+    y2r = x1r + x2r;
+    y2i = x1i + x2i;
+    y6r = x1r - x2r;
+    y6i = x1i - x2i;
+    x0r = a[4] + a[21];
+    x0i = a[5] - a[20];
+    x1r = wk2i * x0r - wk2r * x0i;
+    x1i = wk2i * x0i + wk2r * x0r;
+    x0r = a[12] + a[29];
+    x0i = a[13] - a[28];
+    x2r = wk2r * x0r - wk2i * x0i;
+    x2i = wk2r * x0i + wk2i * x0r;
+    y10r = x1r - x2r;
+    y10i = x1i - x2i;
+    y14r = x1r + x2r;
+    y14i = x1i + x2i;
+    x0r = a[6] - a[23];
+    x0i = a[7] + a[22];
+    x1r = wk3r * x0r - wk3i * x0i;
+    x1i = wk3r * x0i + wk3i * x0r;
+    x0r = a[14] - a[31];
+    x0i = a[15] + a[30];
+    x2r = wk1i * x0r - wk1r * x0i;
+    x2i = wk1i * x0i + wk1r * x0r;
+    y3r = x1r + x2r;
+    y3i = x1i + x2i;
+    y7r = x1r - x2r;
+    y7i = x1i - x2i;
+    x0r = a[6] + a[23];
+    x0i = a[7] - a[22];
+    x1r = wk1i * x0r + wk1r * x0i;
+    x1i = wk1i * x0i - wk1r * x0r;
+    x0r = a[14] + a[31];
+    x0i = a[15] - a[30];
+    x2r = wk3i * x0r - wk3r * x0i;
+    x2i = wk3i * x0i + wk3r * x0r;
+    y11r = x1r + x2r;
+    y11i = x1i + x2i;
+    y15r = x1r - x2r;
+    y15i = x1i - x2i;
+    x1r = y0r + y2r;
+    x1i = y0i + y2i;
+    x2r = y1r + y3r;
+    x2i = y1i + y3i;
+    a[0] = x1r + x2r;
+    a[1] = x1i + x2i;
+    a[2] = x1r - x2r;
+    a[3] = x1i - x2i;
+    x1r = y0r - y2r;
+    x1i = y0i - y2i;
+    x2r = y1r - y3r;
+    x2i = y1i - y3i;
+    a[4] = x1r - x2i;
+    a[5] = x1i + x2r;
+    a[6] = x1r + x2i;
+    a[7] = x1i - x2r;
+    x1r = y4r - y6i;
+    x1i = y4i + y6r;
+    x0r = y5r - y7i;
+    x0i = y5i + y7r;
+    x2r = wn4r * (x0r - x0i);
+    x2i = wn4r * (x0i + x0r);
+    a[8] = x1r + x2r;
+    a[9] = x1i + x2i;
+    a[10] = x1r - x2r;
+    a[11] = x1i - x2i;
+    x1r = y4r + y6i;
+    x1i = y4i - y6r;
+    x0r = y5r + y7i;
+    x0i = y5i - y7r;
+    x2r = wn4r * (x0r - x0i);
+    x2i = wn4r * (x0i + x0r);
+    a[12] = x1r - x2i;
+    a[13] = x1i + x2r;
+    a[14] = x1r + x2i;
+    a[15] = x1i - x2r;
+    x1r = y8r + y10r;
+    x1i = y8i + y10i;
+    x2r = y9r - y11r;
+    x2i = y9i - y11i;
+    a[16] = x1r + x2r;
+    a[17] = x1i + x2i;
+    a[18] = x1r - x2r;
+    a[19] = x1i - x2i;
+    x1r = y8r - y10r;
+    x1i = y8i - y10i;
+    x2r = y9r + y11r;
+    x2i = y9i + y11i;
+    a[20] = x1r - x2i;
+    a[21] = x1i + x2r;
+    a[22] = x1r + x2i;
+    a[23] = x1i - x2r;
+    x1r = y12r - y14i;
+    x1i = y12i + y14r;
+    x0r = y13r + y15i;
+    x0i = y13i - y15r;
+    x2r = wn4r * (x0r - x0i);
+    x2i = wn4r * (x0i + x0r);
+    a[24] = x1r + x2r;
+    a[25] = x1i + x2i;
+    a[26] = x1r - x2r;
+    a[27] = x1i - x2i;
+    x1r = y12r + y14i;
+    x1i = y12i - y14r;
+    x0r = y13r - y15i;
+    x0i = y13i + y15r;
+    x2r = wn4r * (x0r - x0i);
+    x2i = wn4r * (x0i + x0r);
+    a[28] = x1r - x2i;
+    a[29] = x1i + x2r;
+    a[30] = x1r + x2i;
+    a[31] = x1i - x2r;
+}
+
+
+void cftf081(double *a, double *w)
+{
+    double wn4r, x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, 
+        y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i, 
+        y4r, y4i, y5r, y5i, y6r, y6i, y7r, y7i;
+    
+    wn4r = w[1];
+    x0r = a[0] + a[8];
+    x0i = a[1] + a[9];
+    x1r = a[0] - a[8];
+    x1i = a[1] - a[9];
+    x2r = a[4] + a[12];
+    x2i = a[5] + a[13];
+    x3r = a[4] - a[12];
+    x3i = a[5] - a[13];
+    y0r = x0r + x2r;
+    y0i = x0i + x2i;
+    y2r = x0r - x2r;
+    y2i = x0i - x2i;
+    y1r = x1r - x3i;
+    y1i = x1i + x3r;
+    y3r = x1r + x3i;
+    y3i = x1i - x3r;
+    x0r = a[2] + a[10];
+    x0i = a[3] + a[11];
+    x1r = a[2] - a[10];
+    x1i = a[3] - a[11];
+    x2r = a[6] + a[14];
+    x2i = a[7] + a[15];
+    x3r = a[6] - a[14];
+    x3i = a[7] - a[15];
+    y4r = x0r + x2r;
+    y4i = x0i + x2i;
+    y6r = x0r - x2r;
+    y6i = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    x2r = x1r + x3i;
+    x2i = x1i - x3r;
+    y5r = wn4r * (x0r - x0i);
+    y5i = wn4r * (x0r + x0i);
+    y7r = wn4r * (x2r - x2i);
+    y7i = wn4r * (x2r + x2i);
+    a[8] = y1r + y5r;
+    a[9] = y1i + y5i;
+    a[10] = y1r - y5r;
+    a[11] = y1i - y5i;
+    a[12] = y3r - y7i;
+    a[13] = y3i + y7r;
+    a[14] = y3r + y7i;
+    a[15] = y3i - y7r;
+    a[0] = y0r + y4r;
+    a[1] = y0i + y4i;
+    a[2] = y0r - y4r;
+    a[3] = y0i - y4i;
+    a[4] = y2r - y6i;
+    a[5] = y2i + y6r;
+    a[6] = y2r + y6i;
+    a[7] = y2i - y6r;
+}
+
+
+void cftf082(double *a, double *w)
+{
+    double wn4r, wk1r, wk1i, x0r, x0i, x1r, x1i, 
+        y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i, 
+        y4r, y4i, y5r, y5i, y6r, y6i, y7r, y7i;
+    
+    wn4r = w[1];
+    wk1r = w[2];
+    wk1i = w[3];
+    y0r = a[0] - a[9];
+    y0i = a[1] + a[8];
+    y1r = a[0] + a[9];
+    y1i = a[1] - a[8];
+    x0r = a[4] - a[13];
+    x0i = a[5] + a[12];
+    y2r = wn4r * (x0r - x0i);
+    y2i = wn4r * (x0i + x0r);
+    x0r = a[4] + a[13];
+    x0i = a[5] - a[12];
+    y3r = wn4r * (x0r - x0i);
+    y3i = wn4r * (x0i + x0r);
+    x0r = a[2] - a[11];
+    x0i = a[3] + a[10];
+    y4r = wk1r * x0r - wk1i * x0i;
+    y4i = wk1r * x0i + wk1i * x0r;
+    x0r = a[2] + a[11];
+    x0i = a[3] - a[10];
+    y5r = wk1i * x0r - wk1r * x0i;
+    y5i = wk1i * x0i + wk1r * x0r;
+    x0r = a[6] - a[15];
+    x0i = a[7] + a[14];
+    y6r = wk1i * x0r - wk1r * x0i;
+    y6i = wk1i * x0i + wk1r * x0r;
+    x0r = a[6] + a[15];
+    x0i = a[7] - a[14];
+    y7r = wk1r * x0r - wk1i * x0i;
+    y7i = wk1r * x0i + wk1i * x0r;
+    x0r = y0r + y2r;
+    x0i = y0i + y2i;
+    x1r = y4r + y6r;
+    x1i = y4i + y6i;
+    a[0] = x0r + x1r;
+    a[1] = x0i + x1i;
+    a[2] = x0r - x1r;
+    a[3] = x0i - x1i;
+    x0r = y0r - y2r;
+    x0i = y0i - y2i;
+    x1r = y4r - y6r;
+    x1i = y4i - y6i;
+    a[4] = x0r - x1i;
+    a[5] = x0i + x1r;
+    a[6] = x0r + x1i;
+    a[7] = x0i - x1r;
+    x0r = y1r - y3i;
+    x0i = y1i + y3r;
+    x1r = y5r - y7r;
+    x1i = y5i - y7i;
+    a[8] = x0r + x1r;
+    a[9] = x0i + x1i;
+    a[10] = x0r - x1r;
+    a[11] = x0i - x1i;
+    x0r = y1r + y3i;
+    x0i = y1i - y3r;
+    x1r = y5r + y7r;
+    x1i = y5i + y7i;
+    a[12] = x0r - x1i;
+    a[13] = x0i + x1r;
+    a[14] = x0r + x1i;
+    a[15] = x0i - x1r;
+}
+
+
+void cftf040(double *a)
+{
+    double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+    
+    x0r = a[0] + a[4];
+    x0i = a[1] + a[5];
+    x1r = a[0] - a[4];
+    x1i = a[1] - a[5];
+    x2r = a[2] + a[6];
+    x2i = a[3] + a[7];
+    x3r = a[2] - a[6];
+    x3i = a[3] - a[7];
+    a[0] = x0r + x2r;
+    a[1] = x0i + x2i;
+    a[2] = x1r - x3i;
+    a[3] = x1i + x3r;
+    a[4] = x0r - x2r;
+    a[5] = x0i - x2i;
+    a[6] = x1r + x3i;
+    a[7] = x1i - x3r;
+}
+
+
+void cftb040(double *a)
+{
+    double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+    
+    x0r = a[0] + a[4];
+    x0i = a[1] + a[5];
+    x1r = a[0] - a[4];
+    x1i = a[1] - a[5];
+    x2r = a[2] + a[6];
+    x2i = a[3] + a[7];
+    x3r = a[2] - a[6];
+    x3i = a[3] - a[7];
+    a[0] = x0r + x2r;
+    a[1] = x0i + x2i;
+    a[2] = x1r + x3i;
+    a[3] = x1i - x3r;
+    a[4] = x0r - x2r;
+    a[5] = x0i - x2i;
+    a[6] = x1r - x3i;
+    a[7] = x1i + x3r;
+}
+
+
+void cftx020(double *a)
+{
+    double x0r, x0i;
+    
+    x0r = a[0] - a[2];
+    x0i = a[1] - a[3];
+    a[0] += a[2];
+    a[1] += a[3];
+    a[2] = x0r;
+    a[3] = x0i;
+}
+
+
+void rftfsub(int n, double *a, int nc, double *c)
+{
+    int j, k, kk, ks, m;
+    double wkr, wki, xr, xi, yr, yi;
+    
+    m = n >> 1;
+    ks = 2 * nc / m;
+    kk = 0;
+    for (j = 2; j < m; j += 2) {
+        k = n - j;
+        kk += ks;
+        wkr = 0.5 - c[nc - kk];
+        wki = c[kk];
+        xr = a[j] - a[k];
+        xi = a[j + 1] + a[k + 1];
+        yr = wkr * xr - wki * xi;
+        yi = wkr * xi + wki * xr;
+        a[j] -= yr;
+        a[j + 1] -= yi;
+        a[k] += yr;
+        a[k + 1] -= yi;
+    }
+}
+
+
+void rftbsub(int n, double *a, int nc, double *c)
+{
+    int j, k, kk, ks, m;
+    double wkr, wki, xr, xi, yr, yi;
+    
+    m = n >> 1;
+    ks = 2 * nc / m;
+    kk = 0;
+    for (j = 2; j < m; j += 2) {
+        k = n - j;
+        kk += ks;
+        wkr = 0.5 - c[nc - kk];
+        wki = c[kk];
+        xr = a[j] - a[k];
+        xi = a[j + 1] + a[k + 1];
+        yr = wkr * xr + wki * xi;
+        yi = wkr * xi - wki * xr;
+        a[j] -= yr;
+        a[j + 1] -= yi;
+        a[k] += yr;
+        a[k + 1] -= yi;
+    }
+}
+
+
+void dctsub(int n, double *a, int nc, double *c)
+{
+    int j, k, kk, ks, m;
+    double wkr, wki, xr;
+    
+    m = n >> 1;
+    ks = nc / n;
+    kk = 0;
+    for (j = 1; j < m; j++) {
+        k = n - j;
+        kk += ks;
+        wkr = c[kk] - c[nc - kk];
+        wki = c[kk] + c[nc - kk];
+        xr = wki * a[j] - wkr * a[k];
+        a[j] = wkr * a[j] + wki * a[k];
+        a[k] = xr;
+    }
+    a[m] *= c[0];
+}
+
+
+void dstsub(int n, double *a, int nc, double *c)
+{
+    int j, k, kk, ks, m;
+    double wkr, wki, xr;
+    
+    m = n >> 1;
+    ks = nc / n;
+    kk = 0;
+    for (j = 1; j < m; j++) {
+        k = n - j;
+        kk += ks;
+        wkr = c[kk] - c[nc - kk];
+        wki = c[kk] + c[nc - kk];
+        xr = wki * a[k] - wkr * a[j];
+        a[k] = wkr * a[k] + wki * a[j];
+        a[j] = xr;
+    }
+    a[m] *= c[0];
+}
+
diff --git a/modules/visualization/galaktos/func.c b/modules/visualization/galaktos/func.c
new file mode 100644 (file)
index 0000000..6fac372
--- /dev/null
@@ -0,0 +1,222 @@
+/* Function management */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "common.h"
+#include "fatal.h"
+
+#include "func_types.h"
+#include "func.h"
+
+#include "splaytree_types.h"
+#include "splaytree.h"
+#include "tree_types.h"
+
+#include "builtin_funcs.h"
+
+/* A splay tree of builtin functions */
+splaytree_t * builtin_func_tree;
+
+/* Private function prototypes */
+int compare_func(char * name, char * name2);
+int insert_func(func_t * name);
+void * copy_func_key(char * string);
+
+
+void * copy_func_key(char * string) {
+       
+       char * clone_string;
+       
+       if ((clone_string = malloc(MAX_TOKEN_SIZE)) == NULL)
+               return NULL;
+       
+       strncpy(clone_string, string, MAX_TOKEN_SIZE-1);
+       
+       return (void*)clone_string;
+}      
+
+
+func_t * create_func (char * name, double (*func_ptr)(), int num_args) {
+
+  func_t * func;
+  func = (func_t*)malloc(sizeof(func_t));
+  if (func == NULL)
+    return NULL;
+
+  
+  /* Clear name space */
+  memset(func->name, 0, MAX_TOKEN_SIZE);
+
+  /* Copy given name into function structure */
+  strncpy(func->name, name, MAX_TOKEN_SIZE); 
+
+  /* Assign value pointer */
+  func->func_ptr = func_ptr;
+  func->num_args = num_args;
+  /* Return instantiated function */
+  return func;
+
+}
+
+/* Initialize the builtin function database.
+   Should only be necessary once */
+int init_builtin_func_db() {
+  int retval;
+
+  builtin_func_tree = create_splaytree(compare_string, copy_string, free_string);
+
+  if (builtin_func_tree == NULL)
+    return OUTOFMEM_ERROR;
+
+  retval = load_all_builtin_func();
+  return SUCCESS;
+}
+
+
+/* Destroy the builtin function database.
+   Generally, do this on projectm exit */
+int destroy_builtin_func_db() {
+
+  splay_traverse(free_func, builtin_func_tree);
+  destroy_splaytree(builtin_func_tree);
+  return SUCCESS;
+
+}
+
+/* Insert a function into the database */
+int insert_func(func_t * func) {
+
+  if (func == NULL)
+    return ERROR;
+
+  splay_insert(func, func->name, builtin_func_tree);
+
+  return SUCCESS;
+}
+
+/* Frees a function type, real complicated... */
+void free_func(func_t * func) {
+  free(func);
+}
+
+/* Remove a function from the database */
+int remove_func(func_t * func) {
+
+  if (func == NULL)
+    return ERROR;
+
+    splay_delete(func->name, builtin_func_tree);
+
+  return SUCCESS;
+}
+
+/* Find a function given its name */
+func_t * find_func(char * name) {
+
+  func_t * func = NULL;
+
+  /* First look in the builtin database */
+  func = (func_t *)splay_find(name, builtin_func_tree);
+       
+  return func;
+
+}
+
+/* Compare string name with function name */
+int compare_func(char * name, char * name2) {
+
+  int cmpval;
+
+  /* Uses string comparison function */
+  cmpval = strncmp(name, name2, MAX_TOKEN_SIZE-1);
+  
+  return cmpval;
+}
+
+/* Loads a builtin function */
+int load_builtin_func(char * name,  double (*func_ptr)(), int num_args) {
+
+  func_t * func; 
+  int retval; 
+
+  /* Create new function */
+  func = create_func(name, func_ptr, num_args);
+
+  if (func == NULL)
+    return OUTOFMEM_ERROR;
+
+  retval = insert_func(func);
+
+  return retval;
+
+}
+
+/* Loads all builtin functions */
+int load_all_builtin_func() {
+
+  
+  if (load_builtin_func("int", int_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("abs", abs_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("sin", sin_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("cos", cos_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("tan", tan_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("asin", asin_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("acos", acos_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("atan", atan_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("sqr", sqr_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("sqrt", sqrt_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("pow", pow_wrapper, 2) < 0)
+    return ERROR;
+  if (load_builtin_func("exp", exp_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("log", log_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("log10", log10_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("sign", sign_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("min", min_wrapper, 2) < 0)
+    return ERROR;
+  if (load_builtin_func("max", max_wrapper, 2) < 0)
+    return ERROR;
+  if (load_builtin_func("sigmoid", sigmoid_wrapper, 2) < 0)
+    return ERROR;
+  if (load_builtin_func("atan2", atan2_wrapper, 2) < 0)
+    return ERROR;
+  if (load_builtin_func("rand", rand_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("band", band_wrapper, 2) < 0)
+    return ERROR;
+  if (load_builtin_func("bor", bor_wrapper, 2) < 0)
+    return ERROR;
+  if (load_builtin_func("bnot", bnot_wrapper, 1) < 0)
+    return ERROR;
+  if (load_builtin_func("if", if_wrapper, 3) < 0)
+    return ERROR;
+  if (load_builtin_func("equal", equal_wrapper, 2) < 0)
+    return ERROR;
+  if (load_builtin_func("above", above_wrapper, 2) < 0)
+    return ERROR;
+  if (load_builtin_func("below", below_wrapper, 2) < 0)
+    return ERROR;
+  if (load_builtin_func("nchoosek", nchoosek_wrapper, 2) < 0)
+    return ERROR;
+  if (load_builtin_func("fact", fact_wrapper, 1) < 0)
+    return ERROR;
+
+
+  return SUCCESS;
+}
diff --git a/modules/visualization/galaktos/func.h b/modules/visualization/galaktos/func.h
new file mode 100644 (file)
index 0000000..e83acd9
--- /dev/null
@@ -0,0 +1,14 @@
+#ifndef FUNC_H
+#define FUNC_H
+
+/* Public Prototypes */
+func_t * create_func (char * name, double (*func_ptr)(), int num_args);
+int remove_func(func_t * func);
+func_t * find_func(char * name);
+int init_builtin_func_db();
+int destroy_builtin_func_db();
+int load_all_builtin_func();
+int load_builtin_func(char * name, double (*func_ptr)(), int num_args);
+void free_func(func_t * func);
+
+#endif
diff --git a/modules/visualization/galaktos/func_types.h b/modules/visualization/galaktos/func_types.h
new file mode 100644 (file)
index 0000000..dcd7583
--- /dev/null
@@ -0,0 +1,13 @@
+#ifndef FUNC_TYPES_H
+#define FUNC_TYPES_H
+#include "common.h"
+
+
+/* Function Type */
+typedef struct FUNC_T {
+  char name[MAX_TOKEN_SIZE];  
+  double (*func_ptr)();
+  int num_args;
+} func_t;
+
+#endif
index 50b0bc9..64e6019 100644 (file)
@@ -5,6 +5,7 @@
  * $Id$
  *
  * Authors: Cyril Deguet <asmax@videolan.org>
+ *          based on Scivi http://xmms-scivi.sourceforge.net
  *
  * 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
@@ -27,8 +28,8 @@
 #include <GL/glx.h>
 
 /* Local prototypes */
-static int CreateWindow( galaktos_thread_t *p_thread, XVisualInfo *p_vi,
-                         int i_width, int i_height );
+static void CreateWindow( galaktos_thread_t *p_thread, XVisualInfo *p_vi,
+                          int i_width, int i_height, int b_fullscreen );
 
 
 typedef struct
@@ -45,20 +46,28 @@ glx_data_t;
 #define OS_DATA ((glx_data_t*)(p_thread->p_os_data))
 
 
-int galaktos_glx_init( galaktos_thread_t *p_thread, int i_width, int i_height )
+int galaktos_glx_init( galaktos_thread_t *p_thread, int i_width, int i_height,
+                       int b_fullscreen )
 {
     Display *p_display;
     int i_opcode, i_evt, i_err;
     int i_maj, i_min;
     int i_nbelem;
     GLXFBConfig *p_fbconfs, fbconf;
+    XSetWindowAttributes xattr;
     XVisualInfo *p_vi;
     GLXContext gwctx;
     int i;
     GLXPbuffer gpbuf;
+#if 1
     int p_attr[] = { GLX_RED_SIZE, 5, GLX_GREEN_SIZE, 5,
                      GLX_BLUE_SIZE, 5, GLX_DOUBLEBUFFER, True,
                      GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT, 0 };
+#else
+    int p_attr[] = { GLX_RGBA, GLX_RED_SIZE, 5, GLX_GREEN_SIZE, 5,
+                     GLX_BLUE_SIZE, 5, GLX_DOUBLEBUFFER,
+                     0 };
+#endif
 
     /* Initialize OS data */
     p_thread->p_os_data = malloc( sizeof( glx_data_t ) );
@@ -89,6 +98,7 @@ int galaktos_glx_init( galaktos_thread_t *p_thread, int i_width, int i_height )
         msg_Err( p_thread, "glXQueryVersion failed" );
         return -1;
     }
+#if 1
     if( i_maj <= 0 || ((i_maj == 1) && (i_min < 3)) )
     {
         msg_Err( p_thread, "GLX 1.3 is needed" );
@@ -116,16 +126,21 @@ int galaktos_glx_init( galaktos_thread_t *p_thread, int i_width, int i_height )
         XFree( p_fbconfs );
         return -1;
     }
-
-    /* Create the window */
-    if( CreateWindow( p_thread, p_vi, i_width, i_height ) == -1 )
+#else
+    p_vi = glXChooseVisual( p_display, DefaultScreen( p_display), p_attr );
+    if(! p_vi )
     {
-        XFree( p_fbconfs );
-        XFree( p_vi );
+        msg_Err( p_thread, "Cannot get GLX 1.2 visual" );
         return -1;
     }
+#endif
+
+    /* Create the window */
+    CreateWindow( p_thread, p_vi, i_width, i_height, b_fullscreen );
+
     XFree( p_vi );
 
+#if 1
     /* Create the GLX window */
     OS_DATA->gwnd = glXCreateWindow( p_display, fbconf, OS_DATA->wnd, NULL );
     if( OS_DATA->gwnd == None )
@@ -191,10 +206,26 @@ int galaktos_glx_init( galaktos_thread_t *p_thread, int i_width, int i_height )
     }
 
     XFree( p_fbconfs );
+#else
+     /* Create an OpenGL context */
+    OS_DATA->gwctx = gwctx = glXCreateContext( p_display, p_vi, 0, True );
+    if( !gwctx )
+    {
+        msg_Err( p_thread, "Cannot create OpenGL context");
+        XFree( p_fbconfs );
+        return -1;
+    }
+    XFree( p_vi );
+#endif
 
     XMapWindow( p_display, OS_DATA->wnd );
+    if( b_fullscreen )
+    {
+        XMoveWindow( p_display, OS_DATA->wnd, 0, 0 );
+    }
     XFlush( p_display );
-    glXMakeContextCurrent( p_display, OS_DATA->gwnd, OS_DATA->gwnd, gwctx );
+//    glXMakeContextCurrent( p_display, OS_DATA->gwnd, OS_DATA->gwnd, gwctx );
+//    glXMakeCurrent( p_display, OS_DATA->wnd, OS_DATA->gwctx );
 
     return 0;
 }
@@ -229,6 +260,21 @@ int galaktos_glx_handle_events( galaktos_thread_t *p_thread )
 }
 
 
+void galaktos_glx_activate_pbuffer( galaktos_thread_t *p_thread )
+{
+    glXMakeContextCurrent( OS_DATA->p_display, OS_DATA->gpbuf, OS_DATA->gpbuf,
+                           OS_DATA->gpctx );
+}
+
+
+void galaktos_glx_activate_window( galaktos_thread_t *p_thread )
+{
+    glXMakeContextCurrent( OS_DATA->p_display, OS_DATA->gwnd, OS_DATA->gwnd,
+                           OS_DATA->gwctx );
+//    glXMakeCurrent( OS_DATA->p_display, OS_DATA->wnd, OS_DATA->gwctx );
+}
+
+
 void galaktos_glx_swap( galaktos_thread_t *p_thread )
 {
     glXSwapBuffers( OS_DATA->p_display, OS_DATA->gwnd );
@@ -249,13 +295,15 @@ void galaktos_glx_done( galaktos_thread_t *p_thread )
 }
 
 
-int CreateWindow( galaktos_thread_t *p_thread, XVisualInfo *p_vi,
-                  int i_width, int i_height )
+void CreateWindow( galaktos_thread_t *p_thread, XVisualInfo *p_vi,
+                  int i_width, int i_height, int b_fullscreen )
 {
     Display *p_display;
     XSetWindowAttributes xattr;
     Window wnd;
     XSizeHints* p_size_hints;
+    Atom prop;
+    mwmhints_t mwmhints;
 
     p_display = OS_DATA->p_display;
     /* Create the window */
@@ -269,17 +317,26 @@ int CreateWindow( galaktos_thread_t *p_thread, XVisualInfo *p_vi,
     OS_DATA->wm_delete = XInternAtom( p_display, "WM_DELETE_WINDOW", False );
     XSetWMProtocols( p_display, wnd, &OS_DATA->wm_delete, 1 );
 
-    /* Prevent the window from being resized */
-    p_size_hints = XAllocSizeHints();
-    p_size_hints->flags = PMinSize | PMaxSize;
-    p_size_hints->min_width = i_width;
-    p_size_hints->min_height = i_height;
-    p_size_hints->max_width = i_width;
-    p_size_hints->max_height = i_height;
-    XSetWMNormalHints( p_display, wnd, p_size_hints );
-    XFree( p_size_hints );
+    if( b_fullscreen )
+    {
+        mwmhints.flags = MWM_HINTS_DECORATIONS;
+        mwmhints.decorations = False;
 
+        prop = XInternAtom( p_display, "_MOTIF_WM_HINTS", False );
+        XChangeProperty( p_display, wnd, prop, prop, 32, PropModeReplace,
+                         (unsigned char *)&mwmhints, PROP_MWM_HINTS_ELEMENTS );
+    }
+    else
+    {
+        /* Prevent the window from being resized */
+        p_size_hints = XAllocSizeHints();
+        p_size_hints->flags = PMinSize | PMaxSize;
+        p_size_hints->min_width = i_width;
+        p_size_hints->min_height = i_height;
+        p_size_hints->max_width = i_width;
+        p_size_hints->max_height = i_height;
+        XSetWMNormalHints( p_display, wnd, p_size_hints );
+        XFree( p_size_hints );
+    }
     XSelectInput( p_display, wnd, KeyPressMask );
-
-    return 0;
 }
index c3f09f7..11986fa 100644 (file)
 
 #include "plugin.h"
 
-int galaktos_glx_init( galaktos_thread_t *p_thread, int i_width, int i_height );
+int galaktos_glx_init( galaktos_thread_t *p_thread, int i_width, int i_height,
+                       int b_fullscreen );
 void galaktos_glx_done( galaktos_thread_t *p_thread );
 int galaktos_glx_handle_events( galaktos_thread_t *p_thread );
+void galaktos_glx_activate_pbuffer( galaktos_thread_t *p_thread );
+void galaktos_glx_activate_window( galaktos_thread_t *p_thread );
 void galaktos_glx_swap( galaktos_thread_t *p_thread );
 
+/*****************************************************************************
+ * mwmhints_t: window manager hints
+ *****************************************************************************
+ * Fullscreen needs to be able to hide the wm decorations so we provide
+ * this structure to make it easier.
+ *****************************************************************************/
+#define MWM_HINTS_DECORATIONS   (1L << 1)
+#define PROP_MWM_HINTS_ELEMENTS 5
+typedef struct mwmhints_t
+{
+    uint32_t flags;
+    uint32_t functions;
+    uint32_t decorations;
+    int32_t  input_mode;
+    uint32_t status;
+} mwmhints_t;
+
 #endif
diff --git a/modules/visualization/galaktos/idle_preset.h b/modules/visualization/galaktos/idle_preset.h
new file mode 100644 (file)
index 0000000..38294c8
--- /dev/null
@@ -0,0 +1,8 @@
+#ifndef IDLE_PRESET_H
+#include "preset_types.h"
+#define IDLE_PRESET_H
+
+#define IDLE_PRESET_STRING "[idlepreset]\n"
+
+preset_t * idle_preset;
+#endif
diff --git a/modules/visualization/galaktos/init_cond.c b/modules/visualization/galaktos/init_cond.c
new file mode 100644 (file)
index 0000000..e8d246f
--- /dev/null
@@ -0,0 +1,161 @@
+/*****************************************************************************
+ * init_cond.:
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id$
+ *
+ * Authors: Cyril Deguet <asmax@videolan.org>
+ *          code from projectM http://xmms-projectm.sourceforge.net
+ *
+ * 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, USA.
+ *****************************************************************************/
+
+
+
+/* Library functions to manipulate initial condition values */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+#include "fatal.h"
+
+#include "param_types.h"
+#include "expr_types.h"
+#include "init_cond_types.h"
+#include "init_cond.h"
+
+#include "splaytree_types.h"
+#include "splaytree.h"
+char init_cond_string_buffer[STRING_BUFFER_SIZE];
+int init_cond_string_buffer_index = 0;
+
+
+void init_cond_to_string(init_cond_t * init_cond);
+
+/* Frees initial condition structure */
+void free_init_cond(init_cond_t * init_cond) {
+  free(init_cond);
+}
+
+/* Evaluate an initial conditon */
+void eval_init_cond(init_cond_t * init_cond) {
+
+  if (init_cond == NULL)
+    return;
+  /* Parameter is of boolean type, either a 1 or 0 value integer */
+
+  /* Set matrix flag to zero. This ensures
+     its constant value will be used rather than a matrix value 
+  */
+  init_cond->param->matrix_flag = 0;
+  if (init_cond->param->type == P_TYPE_BOOL) {
+        if (INIT_COND_DEBUG) printf("init_cond: %s = %d (TYPE BOOL)\n", init_cond->param->name, init_cond->init_val.bool_val); 
+        *((int*)init_cond->param->engine_val) = init_cond->init_val.bool_val;
+     return;
+  }
+  
+  /* Parameter is an integer type, just like C */
+  
+  if (init_cond->param->type == P_TYPE_INT) {
+        if (INIT_COND_DEBUG) printf("init_cond: %s = %d (TYPE INT)\n", init_cond->param->name, init_cond->init_val.int_val);
+        *((int*)init_cond->param->engine_val) = init_cond->init_val.int_val;
+     return;
+  }
+
+  /* Parameter is of a double type, just like C */
+
+  if (init_cond->param->type == P_TYPE_DOUBLE) {
+       if (INIT_COND_DEBUG) printf("init_cond: %s = %f (TYPE DOUBLE)\n", init_cond->param->name, init_cond->init_val.double_val);
+       *((double*)init_cond->param->engine_val) = init_cond->init_val.double_val;
+    return;
+  }
+
+  /* Unknown type of parameter */
+  return;
+}
+
+/* Creates a new initial condition */
+init_cond_t * new_init_cond(param_t * param, value_t init_val) {
+
+  init_cond_t * init_cond;
+
+  init_cond = (init_cond_t*)malloc(sizeof(init_cond_t));
+   
+  if (init_cond == NULL)
+    return NULL;
+  init_cond->param = param;
+  init_cond->init_val = init_val;
+  return init_cond;
+}
+
+/* WIP */
+void init_cond_to_string(init_cond_t * init_cond) {
+       
+       int string_length;
+       char string[MAX_TOKEN_SIZE];
+       
+       if (init_cond == NULL)
+               return;
+
+       /* Create a string "param_name=val" */
+       switch (init_cond->param->type) {
+               
+               case P_TYPE_BOOL:
+                       sprintf(string, "%s=%d\n", init_cond->param->name, init_cond->init_val.bool_val);
+                       break; 
+               case P_TYPE_INT:
+                       sprintf(string, "%s=%d\n", init_cond->param->name, init_cond->init_val.int_val);
+                       break;
+               case P_TYPE_DOUBLE:
+                       sprintf(string, "%s=%f\n", init_cond->param->name, init_cond->init_val.double_val);
+                       break;
+               default:
+                       return;
+       }               
+               
+       /* Compute the length of the string */
+       string_length = strlen(string);
+       
+       /* Buffer overflow check */
+       if ((init_cond_string_buffer_index + string_length + 1)  > (STRING_BUFFER_SIZE - 1))
+               return;
+       
+       /* Copy the string into the initial condition string buffer */
+       
+       strncpy(init_cond_string_buffer + init_cond_string_buffer_index, string, string_length);
+       
+       /* Increment the string buffer, offset by one for the null terminator, which will be
+          overwritten by the next call to this function */
+       init_cond_string_buffer_index+= string_length + 1;
+               
+}
+
+
+char * create_init_cond_string_buffer(splaytree_t * init_cond_tree) {
+
+       if (init_cond_tree == NULL)
+               return NULL;
+       
+       init_cond_string_buffer_index = 0;
+       
+       splay_traverse(init_cond_to_string, init_cond_tree);
+       
+       return init_cond_string_buffer;
+               
+}
diff --git a/modules/visualization/galaktos/init_cond.h b/modules/visualization/galaktos/init_cond.h
new file mode 100644 (file)
index 0000000..34cbd30
--- /dev/null
@@ -0,0 +1,11 @@
+#ifndef INIT_COND_H
+#define INIT_COND_H
+#define INIT_COND_DEBUG 0
+#include "param_types.h"
+#include "splaytree_types.h"
+
+void eval_init_cond(init_cond_t * init_cond);
+init_cond_t * new_init_cond(param_t * param, value_t init_val);
+void free_init_cond(init_cond_t * init_cond);
+char * create_init_cond_string_buffer(splaytree_t * init_cond_tree);
+#endif
diff --git a/modules/visualization/galaktos/init_cond_types.h b/modules/visualization/galaktos/init_cond_types.h
new file mode 100644 (file)
index 0000000..d339fb1
--- /dev/null
@@ -0,0 +1,11 @@
+#ifndef INIT_COND_TYPES_H
+#define INIT_COND_TYPES_H
+
+#include "param_types.h"
+#include "expr_types.h"
+
+typedef struct INIT_COND_T {
+  struct PARAM_T * param;
+  value_t init_val;
+} init_cond_t;
+#endif
diff --git a/modules/visualization/galaktos/interface_types.h b/modules/visualization/galaktos/interface_types.h
new file mode 100644 (file)
index 0000000..f1aa496
--- /dev/null
@@ -0,0 +1,12 @@
+#ifndef INTERFACE_TYPES_H
+#define INTERFACE_TYPES_H
+typedef enum {
+
+  MENU_INTERFACE,
+  SHELL_INTERFACE,
+  EDITOR_INTERFACE,
+  DEFAULT_INTERFACE,
+  BROWSER_INTERFACE
+} interface_t;
+
+#endif
index 3d29190..dadaef4 100644 (file)
@@ -5,6 +5,7 @@
  * $Id$
  *
  * Authors: Cyril Deguet <asmax@videolan.org>
+ *          Adapted from projectM (http://xmms-projectm.sourceforge.net/)
  *
  * 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
 
 #include "glx.h"
 #include <GL/gl.h>
+#include <GL/glu.h>
 #include <unistd.h>
 #include <math.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "common.h"
+#include "preset_types.h"
+#include "preset.h"
+#include "engine_vars.h"
+#include "per_pixel_eqn_types.h"
+#include "per_pixel_eqn.h"
+#include "interface_types.h"
+#include "video_init.h"             //Video Init Routines, resizing/fullscreen, creating pbuffers
+#include "PCM.h"                    //Sound data handler (buffering, FFT, etc.)
+#include "beat_detect.h"            //beat detection routines
+#include "custom_wave_types.h"
+#include "custom_wave.h"
+#include "custom_shape_types.h"
+#include "custom_shape.h"
+//#include <dmalloc.h>
 
-int galaktos_update( galaktos_thread_t *p_thread, int16_t p_data[2][512] )
+// Forward declarations
+
+void read_cfg();
+
+void modulate_opacity_by_volume();
+void maximize_colors();
+void do_per_pixel_math();
+void do_per_frame();
+
+void render_interpolation();
+void render_texture_to_screen();
+void render_texture_to_studio();
+void draw_motion_vectors();
+void draw_borders();
+void draw_shapes();
+void draw_waveform();
+void draw_custom_waves();
+
+void reset_per_pixel_matrices();
+void init_per_pixel_matrices();
+void free_per_pixel_matrices();
+
+int noSwitch=0;
+int pcmframes=1;
+int freqframes=0;
+int totalframes=1;
+
+int studio=0;
+
+extern preset_t * active_preset;
+
+GLuint RenderTargetTextureID;
+
+double wave_o;
+
+//double gx=32;  //size of interpolation
+//double gy=24;
+
+int texsize=512;   //size of texture to do actual graphics
+int vw=512;           //runtime dimensions
+int vh=512;
+int fullscreen=0;
+
+int maxsamples=2048; //size of PCM buffer
+int numsamples; //size of new PCM info
+double *pcmdataL;     //holder for most recent pcm data
+double *pcmdataR;     //holder for most recent pcm data
+
+int avgtime=500;  //# frames per preset
+
+char *title = NULL;
+int drawtitle;
+int title_font;
+int other_font;
+
+int correction=1;
+
+double vol;
+
+//per pixel equation variables
+
+
+double **gridx;  //grid containing interpolated mesh
+double **gridy;
+double **origtheta;  //grid containing interpolated mesh reference values
+double **origrad;
+double **origx;  //original mesh
+double **origy;
+
+
+
+int galaktos_init( galaktos_thread_t *p_thread )
+{
+    init_per_pixel_matrices();
+    pcmdataL=(double *)malloc(maxsamples*sizeof(double));
+    pcmdataR=(double *)malloc(maxsamples*sizeof(double));
+
+    /* Preset loading function */
+    initPresetLoader();
+
+    /* Load default preset directory */
+ //   loadPresetDir("/home/cyril/.vlc/galaktos");
+    loadPresetDir("/etc/projectM/presets");
+
+    initPCM(maxsamples);
+    initBeatDetect();
+
+    // mutex = SDL_CreateMutex();
+    return 0;
+}
+
+
+void galaktos_done( galaktos_thread_t *p_thread )
 {
-    int j;
+    free(pcmdataL);
+    free(pcmdataR);
+
+    freeBeatDetect();
+    freePCM();
+    free_per_pixel_matrices();
+    closePresetDir();
+//    destroyPresetLoader(); XXX segfaults :(
+}
+
+
+int galaktos_update( galaktos_thread_t *p_thread )
+{
+    static int nohard=0;
+    double vdataL[512];  //holders for FFT data (spectrum)
+    double vdataR[512];
+
+    avgtime=fps*18;
+    totalframes++; //total amount of frames since startup
+
+    Time=(double)(mdate()/1000000);
+
+    frame++;  //number of frames for current preset
+    progress= frame/(double)avgtime;
+    if (progress>1.0) progress=1.0;
+    // printf("start:%d at:%d min:%d stop:%d on:%d %d\n",startframe, frame frame-startframe,avgtime,  noSwitch,progress);
+
+    if (frame>avgtime)
+    {
+        if (noSwitch==0) switchPreset(RANDOM_NEXT,0);
+    }
+
+    evalInitConditions();
+    evalPerFrameEquations();
+
+    evalCustomWaveInitConditions();
+    evalCustomShapeInitConditions();
+
+    //     printf("%f %d\n",Time,frame);
+
+    reset_per_pixel_matrices();
+
+
+    numsamples = getPCMnew(pcmdataR,1,0,fWaveSmoothing,0,0);
+    getPCMnew(pcmdataL,0,0,fWaveSmoothing,0,1);
+    getPCM(vdataL,512,0,1,0,0);
+    getPCM(vdataR,512,1,1,0,0);
+
+    bass=0;mid=0;treb=0;
+
+    getBeatVals(vdataL,vdataR,&vol);
+
+    nohard--;
+    if(vol>8.0 && nohard<0 && noSwitch==0)
+    {
+
+        switchPreset(RANDOM_NEXT, HARD_CUT);
+        nohard=100;
+    }
+
+    //BEGIN PASS 1
+    //
+    //This pass is used to render our texture
+    //the texture is drawn to a subsection of the framebuffer
+    //and then we perform our manipulations on it
+    //in pass 2 we will copy the texture into texture memory
+
+ //   galaktos_glx_activate_pbuffer( p_thread );
+
+    glPushAttrib( GL_ALL_ATTRIB_BITS ); /* Overkill, but safe */
+
+    //   if (RenderTarget) glViewport( 0, 0, RenderTarget->w, RenderTarget->h );
+    if (0) {}
+    else glViewport( 0, 0, texsize, texsize );
+
+
+    glMatrixMode( GL_MODELVIEW );
+    glPushMatrix();
+    glLoadIdentity();
+
+    glMatrixMode( GL_PROJECTION );
+    glPushMatrix();
+    glLoadIdentity();
+
+    glOrtho(0.0, texsize, 0.0,texsize,10,40);
+
+    do_per_pixel_math();
+
+    do_per_frame();               //apply per-frame effects
+    render_interpolation();       //apply per-pixel effects
+    draw_motion_vectors();        //draw motion vectors
+    draw_borders();               //draw borders
+
+    draw_waveform();
+    draw_shapes();
+    draw_custom_waves();
+
+    glMatrixMode( GL_MODELVIEW );
+    glPopMatrix();
+
+    glMatrixMode( GL_PROJECTION );
+    glPopMatrix();
+
+    glPopAttrib();
+
+    //if ( RenderTarget )        SDL_GL_UnlockRenderTarget(RenderTarget);
+        /* Copy our rendering to the fake render target texture */
+    glBindTexture( GL_TEXTURE_2D, RenderTargetTextureID );
+    glCopyTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsize, texsize);
+//    galaktos_glx_activate_window( p_thread );
+
+    //BEGIN PASS 2
+    //
+    //end of texture rendering
+    //now we copy the texture from the framebuffer to
+    //video texture memory and render fullscreen on a quad surface.
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+
+    glFrustum(-vw*.5, vw*.5, -vh*.5,vh*.5,10,40);
+
+    glLineWidth(texsize/512.0);
+    if(studio%2)render_texture_to_studio();
+    else render_texture_to_screen();
+
+    glFinish();
+    glFlush();
+    //  printf("Flush %d\n",(SDL_GetTicks()-timestart));
+    galaktos_glx_swap( p_thread );
 
     /* Process X11 events */
     if( galaktos_glx_handle_events( p_thread ) == 1 )
@@ -36,31 +277,1302 @@ int galaktos_update( galaktos_thread_t *p_thread, int16_t p_data[2][512] )
         return 1;
     }
 
-    glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
+    return 0;
+}
+
+
+void free_per_pixel_matrices()
+{
+    int x;
+
+    for(x = 0; x < gx; x++)
+    {
+        free(gridx[x]);
+        free(gridy[x]);
+        free(origtheta[x]);
+        free(origrad[x]);
+        free(origx[x]);
+        free(origy[x]);
+        free(x_mesh[x]);
+        free(y_mesh[x]);
+        free(rad_mesh[x]);
+        free(theta_mesh[x]);
+    }
+
+    free(origx);
+    free(origy);
+    free(gridx);
+    free(gridy);
+    free(x_mesh);
+    free(y_mesh);
+    free(rad_mesh);
+    free(theta_mesh);
+}
+
+
+void init_per_pixel_matrices()
+{
+    int x,y;
+
+    gridx=(double **)malloc(gx * sizeof(double *));
+    gridy=(double **)malloc(gx * sizeof(double *));
+
+    origx=(double **)malloc(gx * sizeof(double *));
+    origy=(double **)malloc(gx * sizeof(double *));
+    origrad=(double **)malloc(gx * sizeof(double *));
+    origtheta=(double **)malloc(gx * sizeof(double *));
+
+    x_mesh=(double **)malloc(gx * sizeof(double *));
+    y_mesh=(double **)malloc(gx * sizeof(double *));
+    rad_mesh=(double **)malloc(gx * sizeof(double *));
+    theta_mesh=(double **)malloc(gx * sizeof(double *));
+
+    sx_mesh=(double **)malloc(gx * sizeof(double *));
+    sy_mesh=(double **)malloc(gx * sizeof(double *));
+    dx_mesh=(double **)malloc(gx * sizeof(double *));
+    dy_mesh=(double **)malloc(gx * sizeof(double *));
+    cx_mesh=(double **)malloc(gx * sizeof(double *));
+    cy_mesh=(double **)malloc(gx * sizeof(double *));
+    zoom_mesh=(double **)malloc(gx * sizeof(double *));
+    zoomexp_mesh=(double **)malloc(gx * sizeof(double *));
+    rot_mesh=(double **)malloc(gx * sizeof(double *));
+
+    for(x = 0; x < gx; x++)
+    {
+        gridx[x] = (double *)malloc(gy * sizeof(double));
+        gridy[x] = (double *)malloc(gy * sizeof(double));
+
+        origtheta[x] = (double *)malloc(gy * sizeof(double));
+        origrad[x] = (double *)malloc(gy * sizeof(double));
+        origx[x] = (double *)malloc(gy * sizeof(double));
+        origy[x] = (double *)malloc(gy * sizeof(double));
+
+        x_mesh[x] = (double *)malloc(gy * sizeof(double));
+        y_mesh[x] = (double *)malloc(gy * sizeof(double));
+
+        rad_mesh[x] = (double *)malloc(gy * sizeof(double));
+        theta_mesh[x] = (double *)malloc(gy * sizeof(double));
+
+        sx_mesh[x] = (double *)malloc(gy * sizeof(double));
+        sy_mesh[x] = (double *)malloc(gy * sizeof(double));
+        dx_mesh[x] = (double *)malloc(gy * sizeof(double));
+        dy_mesh[x] = (double *)malloc(gy * sizeof(double));
+        cx_mesh[x] = (double *)malloc(gy * sizeof(double));
+        cy_mesh[x] = (double *)malloc(gy * sizeof(double));
+
+        zoom_mesh[x] = (double *)malloc(gy * sizeof(double));
+        zoomexp_mesh[x] = (double *)malloc(gy * sizeof(double));
+
+        rot_mesh[x] = (double *)malloc(gy * sizeof(double));
+    }
+
+    //initialize reference grid values
+    for (x=0;x<gx;x++)
+    {
+        for(y=0;y<gy;y++)
+        {
+            origx[x][y]=x/(double)(gx-1);
+            origy[x][y]=-((y/(double)(gy-1))-1);
+            origrad[x][y]=hypot((origx[x][y]-.5)*2,(origy[x][y]-.5)*2) * .7071067;
+            origtheta[x][y]=atan2(((origy[x][y]-.5)*2),((origx[x][y]-.5)*2));
+            gridx[x][y]=origx[x][y]*texsize;
+            gridy[x][y]=origy[x][y]*texsize;
+        }
+    }
+}
+
+
+
+//calculate matrices for per_pixel
+void do_per_pixel_math()
+{
+    int x,y;
+
+    double rotx=0,roty=0;
+    evalPerPixelEqns();
+
+    if(!isPerPixelEqn(CX_OP))
+    {
+        for (x=0;x<gx;x++)
+        {
+            for(y=0;y<gy;y++){
+                cx_mesh[x][y]=cx;
+            }
+        }
+    }
+
+    if(!isPerPixelEqn(CY_OP))
+    {
+        for (x=0;x<gx;x++)
+        {
+            for(y=0;y<gy;y++)
+            {
+                cy_mesh[x][y]=cy;
+            }
+        }
+    }
+
+    if(isPerPixelEqn(ROT_OP))
+    {
+        for (x=0;x<gx;x++)
+        {
+            for(y=0;y<gy;y++)
+            {
+                x_mesh[x][y]=x_mesh[x][y]-cx_mesh[x][y];
+                y_mesh[x][y]=y_mesh[x][y]-cy_mesh[x][y];
+                rotx=(x_mesh[x][y])*cos(rot_mesh[x][y])-(y_mesh[x][y])*sin(rot_mesh[x][y]);
+                roty=(x_mesh[x][y])*sin(rot_mesh[x][y])+(y_mesh[x][y])*cos(rot_mesh[x][y]);
+                x_mesh[x][y]=rotx+cx_mesh[x][y];
+                y_mesh[x][y]=roty+cy_mesh[x][y];
+            }
+        }
+    }
+
+
+
+    if(!isPerPixelEqn(ZOOM_OP))
+    {
+        for (x=0;x<gx;x++)
+        {
+            for(y=0;y<gy;y++)
+            {
+                zoom_mesh[x][y]=zoom;
+            }
+        }
+    }
+
+    if(!isPerPixelEqn(ZOOMEXP_OP))
+    {
+        for (x=0;x<gx;x++)
+        {
+            for(y=0;y<gy;y++)
+            {
+                zoomexp_mesh[x][y]=zoomexp;
+            }
+        }
+    }
+
+
+    //DO ZOOM PER PIXEL
+    for (x=0;x<gx;x++)
+    {
+        for(y=0;y<gy;y++)
+        {
+            x_mesh[x][y]=(x_mesh[x][y]-.5)*2;
+            y_mesh[x][y]=(y_mesh[x][y]-.5)*2;
+            x_mesh[x][y]=x_mesh[x][y]/(((zoom_mesh[x][y]-1)*(pow(rad_mesh[x][y],zoomexp_mesh[x][y])/rad_mesh[x][y]))+1);
+            y_mesh[x][y]=y_mesh[x][y]/(((zoom_mesh[x][y]-1)*(pow(rad_mesh[x][y],zoomexp_mesh[x][y])/rad_mesh[x][y]))+1);
+            x_mesh[x][y]=(x_mesh[x][y]*.5)+.5;
+            y_mesh[x][y]=(y_mesh[x][y]*.5)+.5;
+        }
+    }
+
+    if(isPerPixelEqn(SX_OP))
+    {
+        for (x=0;x<gx;x++)
+        {
+            for(y=0;y<gy;y++)
+            {
+                x_mesh[x][y]=((x_mesh[x][y]-cx_mesh[x][y])/sx_mesh[x][y])+cx_mesh[x][y];
+            }
+        }
+    }
+
+    if(isPerPixelEqn(SY_OP))
+    {
+        for (x=0;x<gx;x++)
+        {
+            for(y=0;y<gy;y++)
+            {
+                y_mesh[x][y]=((y_mesh[x][y]-cy_mesh[x][y])/sy_mesh[x][y])+cy_mesh[x][y];
+            }
+        }
+    }
+
+    if(isPerPixelEqn(DX_OP))
+    {
+        for (x=0;x<gx;x++)
+        {
+            for(y=0;y<gy;y++)
+            {
+
+                x_mesh[x][y]=x_mesh[x][y]-dx_mesh[x][y];
+
+            }
+        }
+    }
+
+    if(isPerPixelEqn(DY_OP))
+    {
+        for (x=0;x<gx;x++)
+        {
+            for(y=0;y<gy;y++)
+            {
+                y_mesh[x][y]=y_mesh[x][y]-dy_mesh[x][y];
+
+            }
+        }
+    }
+
+
+}
+
+void reset_per_pixel_matrices()
+{
+    int x,y;
+
+    for (x=0;x<gx;x++)
+    {
+        for(y=0;y<gy;y++)
+        {
+            x_mesh[x][y]=origx[x][y];
+            y_mesh[x][y]=origy[x][y];
+            rad_mesh[x][y]=origrad[x][y];
+            theta_mesh[x][y]=origtheta[x][y];
+        }
+    }
+}
+
+
+
+void draw_custom_waves()
+{
+    int x;
+
+    custom_wave_t *wavecode;
+    glPointSize(texsize/512);
+    //printf("%d\n",wavecode);
+    //  more=isMoreCustomWave();
+    // printf("not inner loop\n");
+    while ((wavecode = nextCustomWave()) != NULL)
+    {
+        //printf("begin inner loop\n");
+        if(wavecode->enabled==1)
+        {
+            // nextCustomWave();
+
+            //glPushMatrix();
+
+            //if(wavecode->bUseDots==1) glEnable(GL_LINE_STIPPLE);
+            if (wavecode->bAdditive==0)  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            else    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+            if (wavecode->bDrawThick==1)  glLineWidth(2*texsize/512);
+
+            //  xx= ((pcmdataL[x]-pcmdataL[x-1])*80*fWaveScale)*2;
+            //yy=pcmdataL[x]*80*fWaveScale,-1;
+            //glVertex3f( (wave_x*texsize)+(xx+yy)*cos(45), (wave_y*texsize)+(-yy+xx)*cos(45),-1);
+            // printf("samples: %d\n", wavecode->samples);
+
+            getPCM(wavecode->value1,wavecode->samples,0,wavecode->bSpectrum,wavecode->smoothing,0);
+            getPCM(wavecode->value2,wavecode->samples,1,wavecode->bSpectrum,wavecode->smoothing,0);
+            // printf("%f\n",pcmL[0]);
+            for(x=0;x<wavecode->samples;x++)
+            {wavecode->value1[x]=wavecode->value1[x]*wavecode->scaling;}
+
+            for(x=0;x<wavecode->samples;x++)
+            {wavecode->value2[x]=wavecode->value2[x]*wavecode->scaling;}
+
+            for(x=0;x<wavecode->samples;x++)
+            {wavecode->sample_mesh[x]=((double)x)/((double)(wavecode->samples-1));}
+
+            // printf("mid inner loop\n");
+            evalPerPointEqns();
+            /*
+               if(!isPerPointEquation("x"))
+               {for(x=0;x<wavecode->samples;x++)
+               {cw_x[x]=0;} }
+
+               if(!isPerPointEquation(Y_POINT_OP))
+               {for(x=0;x<wavecode->samples;x++)
+               {cw_y[x]=0;}}
+
+               if(!isPerPointEquation(R_POINT_OP))
+               {for(x=0;x<wavecode->samples;x++)
+               {cw_r[x]=wavecode->r;}}
+               if(!isPerPointEquation(G_POINT_OP))
+               {for(x=0;x<wavecode->samples;x++)
+               {cw_g[x]=wavecode->g;}}
+               if(!isPerPointEquation(B_POINT_OP))
+               {for(x=0;x<wavecode->samples;x++)
+               {cw_b[x]=wavecode->b;}}
+               if(!isPerPointEquation(A_POINT_OP))
+               {for(x=0;x<wavecode->samples;x++)
+               {cw_a[x]=wavecode->a;}}
+             */
+            //put drawing code here
+            if (wavecode->bUseDots==1)   glBegin(GL_POINTS);
+            else   glBegin(GL_LINE_STRIP);
+
+            for(x=0;x<wavecode->samples;x++)
+            {
+                //          printf("x:%f y:%f a:%f g:%f %f\n", wavecode->x_mesh[x], wavecode->y_mesh[x], wavecode->a_mesh[x], wavecode->g_mesh[x], wavecode->sample_mesh[x]);
+                glColor4f(wavecode->r_mesh[x],wavecode->g_mesh[x],wavecode->b_mesh[x],wavecode->a_mesh[x]);
+                glVertex3f(wavecode->x_mesh[x]*texsize,-(wavecode->y_mesh[x]-1)*texsize,-1);
+            }
+            glEnd();
+            glPointSize(texsize/512);
+            glLineWidth(texsize/512);
+            glDisable(GL_LINE_STIPPLE);
+            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            //  glPopMatrix();
+
+        }
+
+    }
+}
+
+
+
+void draw_shapes()
+{
+    int i;
+
+    double theta;
+    double rad2;
+
+    double pi = 3.14159265;
+    double start,inc,xval,yval;
+    custom_shape_t *shapecode;
+
+    while ((shapecode = nextCustomShape()) != NULL)
+    {
+        if(shapecode->enabled==1)
+        {
+            // printf("drawing shape %f\n",shapecode->ang);
+            shapecode->y=-((shapecode->y)-1);
+            rad2=.5;
+            shapecode->rad=shapecode->rad*(texsize*.707*.707*.707*1.04);
+            //Additive Drawing or Overwrite
+            if (shapecode->additive==0)  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            else    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+
+            glMatrixMode(GL_MODELVIEW);
+            glPushMatrix();
+            if(correction)
+            {
+                glTranslatef(texsize*.5,texsize*.5, 0);
+                glScalef(1.0,vw/(double)vh,1.0);
+                glTranslatef((-texsize*.5) ,(-texsize*.5),0);
+            }
+
+            start=.78539+shapecode->ang;
+            inc=(pi*2)/(double)shapecode->sides;
+            xval=shapecode->x*texsize;
+            yval=shapecode->y*texsize;
+
+            if (shapecode->textured)
+            {
+                glMatrixMode(GL_TEXTURE);
+                glPushMatrix();
+                glLoadIdentity();
+
+                glTranslatef(.5,.5, 0);
+                if (correction) glScalef(1,vw/(double)vh,1);
+
+                glRotatef((shapecode->tex_ang*360/6.280), 0, 0, 1);
+
+                glScalef(1/(shapecode->tex_zoom),1/(shapecode->tex_zoom),1);
+
+                // glScalef(1,vh/(double)vw,1);
+                glTranslatef((-.5) ,(-.5),0);
+                // glScalef(1,vw/(double)vh,1);
+                glEnable(GL_TEXTURE_2D);
+
+
+                glBegin(GL_TRIANGLE_FAN);
+
+                glColor4f(shapecode->r,shapecode->g,shapecode->b,shapecode->a);
+                theta=start;
+                glTexCoord2f(.5,.5);
+                glVertex3f(xval,yval,-1);
+                glColor4f(shapecode->r2,shapecode->g2,shapecode->b2,shapecode->a2);
+
+                for ( i=0;i<shapecode->sides+1;i++)
+                {
+
+                    theta+=inc;
+                    //  glColor4f(shapecode->r2,shapecode->g2,shapecode->b2,shapecode->a2);
+                    glTexCoord2f(rad2*cos(theta)+.5 ,rad2*sin(theta)+.5 );
+                    glVertex3f(shapecode->rad*cos(theta)+xval,shapecode->rad*sin(theta)+yval,-1);
+                }
+                glEnd();
+
+
+
+
+                glDisable(GL_TEXTURE_2D);
+                glPopMatrix();
+                glMatrixMode(GL_MODELVIEW);
+            }
+            else
+            {//Untextured (use color values)
+                //printf("untextured %f %f %f @:%f,%f %f %f\n",shapecode->a2,shapecode->a,shapecode->border_a, shapecode->x,shapecode->y,shapecode->rad,shapecode->ang);
+                //draw first n-1 triangular pieces
+                glBegin(GL_TRIANGLE_FAN);
+
+                glColor4f(shapecode->r,shapecode->g,shapecode->b,shapecode->a);
+                theta=start;
+                // glTexCoord2f(.5,.5);
+                glVertex3f(xval,yval,-1);
+                glColor4f(shapecode->r2,shapecode->g2,shapecode->b2,shapecode->a2);
+
+                for ( i=0;i<shapecode->sides+1;i++)
+                {
+
+                    theta+=inc;
+                    //  glColor4f(shapecode->r2,shapecode->g2,shapecode->b2,shapecode->a2);
+                    //  glTexCoord2f(rad2*cos(theta)+.5 ,rad2*sin(theta)+.5 );
+                    glVertex3f(shapecode->rad*cos(theta)+xval,shapecode->rad*sin(theta)+yval,-1);
+                }
+                glEnd();
+
+
+            }
+            if (bWaveThick==1)  glLineWidth(2*texsize/512);
+            glBegin(GL_LINE_LOOP);
+            glColor4f(shapecode->border_r,shapecode->border_g,shapecode->border_b,shapecode->border_a);
+            for ( i=0;i<shapecode->sides;i++)
+            {
+                theta+=inc;
+                glVertex3f(shapecode->rad*cos(theta)+xval,shapecode->rad*sin(theta)+yval,-1);
+            }
+            glEnd();
+            if (bWaveThick==1)  glLineWidth(texsize/512);
+
+            glPopMatrix();
+        }
+    }
+
+}
+
+
+void draw_waveform()
+{
+
+    int x;
+
+    double r,theta;
+
+    double offset,scale,dy2_adj;
+
+    double co;
+
+    double wave_x_temp=0;
+    double wave_y_temp=0;
+
+    modulate_opacity_by_volume();
+    maximize_colors();
+
+    if(bWaveDots==1) glEnable(GL_LINE_STIPPLE);
+
+    offset=(wave_x-.5)*texsize;
+    scale=texsize/505.0;
+
+    //Thick wave drawing
+    if (bWaveThick==1)  glLineWidth(2*texsize/512);
+
+    //Additive wave drawing (vice overwrite)
+    if (bAdditiveWaves==0)  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    else    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+
+    switch(nWaveMode)
+    {
+        case 8://monitor
+
+            glPushMatrix();
+
+            glTranslatef(texsize*.5,texsize*.5, 0);
+            glRotated(-wave_mystery*90,0,0,1);
+
+            glTranslatef(-texsize*.5,-texsize*.825, 0);
+
+            /*
+               for (x=0;x<16;x++)
+               {
+               glBegin(GL_LINE_STRIP);
+               glColor4f(1.0-(x/15.0),.5,x/15.0,1.0);
+               glVertex3f((totalframes%256)*2*scale, -beat_val[x]*fWaveScale+texsize*wave_y,-1);
+               glColor4f(.5,.5,.5,1.0);
+               glVertex3f((totalframes%256)*2*scale, texsize*wave_y,-1);
+               glColor4f(1.0,1.0,0,1.0);
+            //glVertex3f((totalframes%256)*scale*2, beat_val_att[x]*fWaveScale+texsize*wave_y,-1);
+            glEnd();
+
+            glTranslatef(0,texsize*(1/36.0), 0);
+            }
+             */
+
+            glTranslatef(0,texsize*(1/18.0), 0);
+
+
+            glBegin(GL_LINE_STRIP);
+            glColor4f(1.0,1.0,0.5,1.0);
+            glVertex3f((totalframes%256)*2*scale, treb_att*5*fWaveScale+texsize*wave_y,-1);
+            glColor4f(.2,.2,.2,1.0);
+            glVertex3f((totalframes%256)*2*scale, texsize*wave_y,-1);
+            glColor4f(1.0,1.0,0,1.0);
+            glVertex3f((totalframes%256)*scale*2, treb*-5*fWaveScale+texsize*wave_y,-1);
+            glEnd();
+
+            glTranslatef(0,texsize*.075, 0);
+            glBegin(GL_LINE_STRIP);
+            glColor4f(0,1.0,0.0,1.0);
+            glVertex3f((totalframes%256)*2*scale, mid_att*5*fWaveScale+texsize*wave_y,-1);
+            glColor4f(.2,.2,.2,1.0);
+            glVertex3f((totalframes%256)*2*scale, texsize*wave_y,-1);
+            glColor4f(.5,1.0,.5,1.0);
+            glVertex3f((totalframes%256)*scale*2, mid*-5*fWaveScale+texsize*wave_y,-1);
+            glEnd();
+
+
+            glTranslatef(0,texsize*.075, 0);
+            glBegin(GL_LINE_STRIP);
+            glColor4f(1.0,0,0,1.0);
+            glVertex3f((totalframes%256)*2*scale, bass_att*5*fWaveScale+texsize*wave_y,-1);
+            glColor4f(.2,.2,.2,1.0);
+            glVertex3f((totalframes%256)*2*scale, texsize*wave_y,-1);
+            glColor4f(1.0,.5,.5,1.0);
+            glVertex3f((totalframes%256)*scale*2, bass*-5*fWaveScale+texsize*wave_y,-1);
+            glEnd();
+
+
+            glPopMatrix();
+            break;
+
+        case 0://circular waveforms
+            //  double co;
+            glPushMatrix();
+
+            glTranslatef(texsize*.5,texsize*.5, 0);
+            glScalef(1.0,vw/(double)vh,1.0);
+            glTranslatef((-texsize*.5) ,(-texsize*.5),0);
+
+            wave_y=-1*(wave_y-1.0);
+
+            glBegin(GL_LINE_STRIP);
+
+            for ( x=0;x<numsamples;x++)
+            {
+                co= -(abs(x-((numsamples*.5)-1))/numsamples)+1;
+                // printf("%d %f\n",x,co);
+                theta=x*(6.28/numsamples);
+                r= ((1+2*wave_mystery)*(texsize/5.0)+
+                    ( co*pcmdataL[x]+ (1-co)*pcmdataL[-(x-(numsamples-1))])
+                    *25*fWaveScale);
+
+                glVertex3f(r*cos(theta)+(wave_x*texsize),r*sin(theta)+(wave_y*texsize),-1);
+            }
+
+            r= ( (1+2*wave_mystery)*(texsize/5.0)+
+                 (0.5*pcmdataL[0]+ 0.5*pcmdataL[numsamples-1])
+                 *20*fWaveScale);
+
+            glVertex3f(r*cos(0)+(wave_x*texsize),r*sin(0)+(wave_y*texsize),-1);
+
+            glEnd();
+            /*
+               glBegin(GL_LINE_LOOP);
+
+               for ( x=0;x<(512/pcmbreak);x++)
+               {
+               theta=(blockstart+x)*((6.28*pcmbreak)/512.0);
+               r= ((1+2*wave_mystery)*(texsize/5.0)+fdata_buffer[fbuffer][0][blockstart+x]*.0025*fWaveScale);
+
+               glVertex3f(r*cos(theta)+(wave_x*texsize),r*sin(theta)+(wave_y*texsize),-1);
+               }
+               glEnd();
+             */
+            glPopMatrix();
+
+            break;
+
+        case 1://circularly moving waveform
+            //  double co;
+            glPushMatrix();
+
+            glTranslatef(texsize*.5,texsize*.5, 0);
+            glScalef(1.0,vw/(double)vh,1.0);
+            glTranslatef((-texsize*.5) ,(-texsize*.5),0);
+
+            wave_y=-1*(wave_y-1.0);
+
+            glBegin(GL_LINE_STRIP);
+            //theta=(frame%512)*(6.28/512.0);
+
+            for ( x=1;x<512;x++)
+            {
+                co= -(abs(x-255)/512.0)+1;
+                // printf("%d %f\n",x,co);
+                theta=((frame%256)*(2*6.28/512.0))+pcmdataL[x]*.2*fWaveScale;
+                r= ((1+2*wave_mystery)*(texsize/5.0)+
+                    (pcmdataL[x]-pcmdataL[x-1])*80*fWaveScale);
+
+                glVertex3f(r*cos(theta)+(wave_x*texsize),r*sin(theta)+(wave_y*texsize),-1);
+            }
+
+            glEnd();
+
+            glPopMatrix();
+
+            break;
+
+        case 2://EXPERIMENTAL
+            wave_y=-1*(wave_y-1.0);
+            glPushMatrix();
+            glBegin(GL_LINE_STRIP);
+            double xx,yy;
+            // double xr= (wave_x*texsize), yr=(wave_y*texsize);
+            xx=0;
+            for ( x=1;x<512;x++)
+            {
+                //xx = ((pcmdataL[x]-pcmdataL[x-1])*80*fWaveScale)*2;
+                xx += (pcmdataL[x]*fWaveScale);
+                yy= pcmdataL[x]*80*fWaveScale;
+                //  glVertex3f( (wave_x*texsize)+(xx+yy)*2, (wave_y*texsize)+(xx-yy)*2,-1);
+                glVertex3f( (wave_x*texsize)+(xx)*2, (wave_y*texsize)+(yy)*2,-1);
+
+
+                //   xr+=fdata_buffer[fbuffer][0][x] *.0005* fWaveScale;
+                //yr=(fdata_buffer[fbuffer][0][x]-fdata_buffer[fbuffer][0][x-1])*.05*fWaveScale+(wave_y*texsize);
+                //glVertex3f(xr,yr,-1);
+
+            }
+            glEnd();
+            glPopMatrix();
+            break;
+
+        case 3://EXPERIMENTAL
+            glPushMatrix();
+            wave_y=-1*(wave_y-1.0);
+            glBegin(GL_LINE_STRIP);
+
+
+            for ( x=1;x<512;x++)
+            {
+                xx= ((pcmdataL[x]-pcmdataL[x-1])*80*fWaveScale)*2;
+                yy=pcmdataL[x]*80*fWaveScale,-1;
+                glVertex3f( (wave_x*texsize)+(xx+yy)*cos(45), (wave_y*texsize)+(-yy+xx)*cos(45),-1);
+            }
+            glEnd();
+            glPopMatrix();
+            break;
+
+        case 4://single x-axis derivative waveform
+            glPushMatrix();
+            wave_y=-1*(wave_y-1.0);
+            glTranslatef(texsize*.5,texsize*.5, 0);
+            glRotated(-wave_mystery*90,0,0,1);
+            glTranslatef(-texsize*.5,-texsize*.5, 0);
+            wave_x=(wave_x*.75)+.125;      wave_x=-(wave_x-1);
+            glBegin(GL_LINE_STRIP);
+
+            double dy_adj;
+            for ( x=1;x<512;x++)
+            {
+                dy_adj=  pcmdataL[x]*20*fWaveScale-pcmdataL[x-1]*20*fWaveScale;
+                glVertex3f((x*scale)+dy_adj, pcmdataL[x]*20*fWaveScale+texsize*wave_x,-1);
+            }
+            glEnd();
+            glPopMatrix();
+            break;
+
+        case 5://EXPERIMENTAL
+            glPushMatrix();
+
+
+            wave_y=-1*(wave_y-1.0);
+            wave_x_temp=(wave_x*.75)+.125;
+            wave_x_temp=-(wave_x_temp-1);
+            glBegin(GL_LINE_STRIP);
+
+            for ( x=1;x<(512);x++)
+            {
+                dy2_adj=  (pcmdataL[x]-pcmdataL[x-1])*20*fWaveScale;
+                glVertex3f((wave_x_temp*texsize)+dy2_adj*2, pcmdataL[x]*20*fWaveScale+texsize*wave_y,-1);
+            }
+            glEnd();
+            glPopMatrix();
+            break;
+
+        case 6://single waveform
+
+
+
+
+            glTranslatef(0,0, -1);
+
+            //glMatrixMode(GL_MODELVIEW);
+            glPushMatrix();
+            //            glLoadIdentity();
+
+            glTranslatef(texsize*.5,texsize*.5, 0);
+            glRotated(-wave_mystery*90,0,0,1);
+
+            wave_x_temp=-2*0.4142*(abs(abs(wave_mystery)-.5)-.5);
+            glScalef(1.0+wave_x_temp,1.0,1.0);
+            glTranslatef(-texsize*.5,-texsize*.5, 0);
+            wave_x_temp=-1*(wave_x-1.0);
+
+            glBegin(GL_LINE_STRIP);
+            //      wave_x_temp=(wave_x*.75)+.125;
+            //      wave_x_temp=-(wave_x_temp-1);
+            for ( x=0;x<numsamples;x++)
+            {
+
+                //glVertex3f(x*scale, fdata_buffer[fbuffer][0][blockstart+x]*.0012*fWaveScale+texsize*wave_x_temp,-1);
+                glVertex3f(x*texsize/(double)numsamples, pcmdataR[x]*20*fWaveScale+texsize*wave_x_temp,-1);
+
+                //glVertex3f(x*scale, texsize*wave_y_temp,-1);
+            }
+            //      printf("%f %f\n",texsize*wave_y_temp,wave_y_temp);
+            glEnd();
+            glPopMatrix();
+            break;
+
+        case 7://dual waveforms
+
+            glPushMatrix();
+
+            glTranslatef(texsize*.5,texsize*.5, 0);
+            glRotated(-wave_mystery*90,0,0,1);
+
+            wave_x_temp=-2*0.4142*(abs(abs(wave_mystery)-.5)-.5);
+            glScalef(1.0+wave_x_temp,1.0,1.0);
+            glTranslatef(-texsize*.5,-texsize*.5, 0);
+
+            wave_y_temp=-1*(wave_x-1);
+
+            glBegin(GL_LINE_STRIP);
+
+            for ( x=0;x<numsamples;x++)
+            {
+
+                glVertex3f((x*texsize)/(double)numsamples, pcmdataL[x]*20*fWaveScale+texsize*(wave_y_temp+(wave_y*wave_y*.5)),-1);
+            }
+            glEnd();
+
+            glBegin(GL_LINE_STRIP);
+
+
+            for ( x=0;x<numsamples;x++)
+            {
+
+                glVertex3f((x*texsize)/(double)numsamples, pcmdataR[x]*20*fWaveScale+texsize*(wave_y_temp-(wave_y*wave_y*.5)),-1);
+            }
+            glEnd();
+            glPopMatrix();
+            break;
+
+        default:
+            glBegin(GL_LINE_LOOP);
+
+            for ( x=0;x<512;x++)
+            {
+                theta=(x)*(6.28/512.0);
+                r= (texsize/5.0+pcmdataL[x]*.002);
+
+                glVertex3f(r*cos(theta)+(wave_x*texsize),r*sin(theta)+(wave_y*texsize),-1);
+            }
+            glEnd();
+
+            glBegin(GL_LINE_STRIP);
+
+            for ( x=0;x<512;x++)
+            {
+                glVertex3f(x*scale, pcmdataL[x]*20*fWaveScale+(texsize*(wave_x+.1)),-1);
+            }
+            glEnd();
+
+            glBegin(GL_LINE_STRIP);
+
+            for ( x=0;x<512;x++)
+            {
+                glVertex3f(x*scale, pcmdataR[x]*20*fWaveScale+(texsize*(wave_x-.1)),-1);
+
+            }
+            glEnd();
+            break;
+            if (bWaveThick==1)  glLineWidth(2*texsize/512);
+    }
+    glLineWidth(texsize/512);
+    glDisable(GL_LINE_STIPPLE);
+}
+
+
+void maximize_colors()
+{
+    float wave_r_switch=0,wave_g_switch=0,wave_b_switch=0;
+    //wave color brightening
+    //
+    //forces max color value to 1.0 and scales
+    // the rest accordingly
+
+    if (bMaximizeWaveColor==1)
+    {
+        if(wave_r>=wave_g && wave_r>=wave_b)   //red brightest
+        {
+            wave_b_switch=wave_b*(1/wave_r);
+            wave_g_switch=wave_g*(1/wave_r);
+            wave_r_switch=1.0;
+        }
+        else if   (wave_b>=wave_g && wave_b>=wave_r)         //blue brightest
+        {
+            wave_r_switch=wave_r*(1/wave_b);
+            wave_g_switch=wave_g*(1/wave_b);
+            wave_b_switch=1.0;
+
+        }
+
+        else  if (wave_g>=wave_b && wave_g>=wave_r)         //green brightest
+        {
+            wave_b_switch=wave_b*(1/wave_g);
+            wave_r_switch=wave_r*(1/wave_g);
+            wave_g_switch=1.0;
+        }
+        glColor4f(wave_r_switch, wave_g_switch, wave_b_switch, wave_o);
+    }
+    else
+    {
+        glColor4f(wave_r, wave_g, wave_b, wave_o);
+    }
+
+}
+
+
+void modulate_opacity_by_volume()
+
+{
+    //modulate volume by opacity
+    //
+    //set an upper and lower bound and linearly
+    //calculate the opacity from 0=lower to 1=upper
+    //based on current volume
+
+    if (bModWaveAlphaByVolume==1)
+    {if (vol<=fModWaveAlphaStart)  wave_o=0.0;
+        else if (vol>=fModWaveAlphaEnd) wave_o=fWaveAlpha;
+        else wave_o=fWaveAlpha*((vol-fModWaveAlphaStart)/(fModWaveAlphaEnd-fModWaveAlphaStart));}
+    else wave_o=fWaveAlpha;
+}
+
+
+void draw_motion_vectors()
+{
+    int x,y;
+
+    double offsetx=mv_dx*texsize, intervalx=texsize/(double)mv_x;
+    double offsety=mv_dy*texsize, intervaly=texsize/(double)mv_y;
+
+    glPointSize(mv_l);
+    glColor4f(mv_r, mv_g, mv_b, mv_a);
+    glBegin(GL_POINTS);
+    for (x=0;x<mv_x;x++){
+        for(y=0;y<mv_y;y++){
+            glVertex3f(offsetx+x*intervalx,offsety+y*intervaly,-1);
+        }}
+
+    glEnd();
+}
+
+
+void draw_borders()
+{
+    //no additive drawing for borders
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    glTranslatef(0,0,-1);
+    //Draw Borders
+    double of=texsize*ob_size*.5;
+    double iff=(texsize*ib_size*.5);
+    double texof=texsize-of;
+
+    glColor4d(ob_r,ob_g,ob_b,ob_a);
+
+    glRectd(0,0,of,texsize);
+    glRectd(of,0,texof,of);
+    glRectd(texof,0,texsize,texsize);
+    glRectd(of,texsize,texof,texof);
+    glColor4d(ib_r,ib_g,ib_b,ib_a);
+    glRectd(of,of,of+iff,texof);
+    glRectd(of+iff,of,texof-iff,of+iff);
+    glRectd(texof-iff,of,texof,texof);
+    glRectd(of+iff,texof,texof-iff,texof-iff);
+}
+
+
+//Here we render the interpolated mesh, and then apply the texture to it.
+//Well, we actually do the inverse, but its all the same.
+void render_interpolation()
+{
+
+    int x,y;
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    glTranslated(0, 0, -9);
+
+    glColor4f(0.0, 0.0, 0.0,decay);
+
+    glEnable(GL_TEXTURE_2D);
+
+    for (x=0;x<gx-1;x++)
+    {
+        glBegin(GL_TRIANGLE_STRIP);
+        for(y=0;y<gy;y++)
+        {
+            glTexCoord4f(x_mesh[x][y], y_mesh[x][y],-1,1); glVertex4f(gridx[x][y], gridy[x][y],-1,1);
+            glTexCoord4f(x_mesh[x+1][y], y_mesh[x+1][y],-1,1); glVertex4f(gridx[x+1][y], gridy[x+1][y],-1,1);
+        }
+        glEnd();
+    }
+    glDisable(GL_TEXTURE_2D);
+}
+
+
+void do_per_frame()
+{
+    //Texture wrapping( clamp vs. wrap)
+    if (bTexWrap==0)
+    {
+        glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+        glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+    }
+    else
+    {
+        glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+        glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+    }
+
+
+    //      glRasterPos2i(0,0);
+    //      glClear(GL_COLOR_BUFFER_BIT);
+    //      glColor4d(0.0, 0.0, 0.0,1.0);
+
+    //      glMatrixMode(GL_TEXTURE);
+    //  glLoadIdentity();
+
+    glRasterPos2i(0,0);
     glClear(GL_COLOR_BUFFER_BIT);
+    glColor4d(0.0, 0.0, 0.0,1.0);
+
+    glMatrixMode(GL_TEXTURE);
+    glLoadIdentity();
 
-    glBegin(GL_TRIANGLE_STRIP);
-        glColor3f( 0.5f, 0.0f, 0.0f);
-        glVertex2f(  -1.0f,  1.0f);
-        glColor3f( 0.2f, 0.2f, 0.0f);
-        glVertex2f(  1.0f,  1.0f);
-        glColor3f( 0.0f, 0.2f, 0.2f);
-        glVertex2f(  -1.0f,  -1.0f);
-        glColor3f( 0.0f, 0.0f, 0.5f);
-        glVertex2f(  1.0f,  -1.0f);
+    glTranslatef(cx,cy, 0);
+    if(correction)  glScalef(1,vw/(double)vh,1);
+
+    if(!isPerPixelEqn(ROT_OP))
+    {
+        //    printf("ROTATING: rot = %f\n", rot);
+        glRotatef(rot*90, 0, 0, 1);
+    }
+    if(!isPerPixelEqn(SX_OP)) glScalef(1/sx,1,1);
+    if(!isPerPixelEqn(SY_OP)) glScalef(1,1/sy,1);
+
+    if(correction) glScalef(1,vh/(double)vw,1);
+    glTranslatef((-cx) ,(-cy),0);
+
+    if(!isPerPixelEqn(DX_OP)) glTranslatef(-dx,0,0);
+    if(!isPerPixelEqn(DY_OP)) glTranslatef(0 ,-dy,0);
+
+}
+
+
+//Actually draws the texture to the screen
+//
+//The Video Echo effect is also applied here
+void render_texture_to_screen()
+{
+    glMatrixMode(GL_TEXTURE);
+    glLoadIdentity();
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    glTranslatef(0, 0, -9);
+
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,  GL_DECAL);
+    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
+
+    //       glClear(GL_ACCUM_BUFFER_BIT);
+    glColor4d(0.0, 0.0, 0.0,1.0f);
+
+    glBegin(GL_QUADS);
+    glVertex4d(-vw*.5,-vh*.5,-1,1);
+    glVertex4d(-vw*.5,  vh*.5,-1,1);
+    glVertex4d(vw*.5,  vh*.5,-1,1);
+    glVertex4d(vw*.5, -vh*.5,-1,1);
     glEnd();
-    glBegin(GL_LINE_STRIP);
-        glColor3f( 1.0f, 1.0f, 1.0f);
-        glVertex2f( -1.0f, 0.0f);
-        for(j=0; j<512; j++)
+
+    //      glBindTexture( GL_TEXTURE_2D, tex2 );
+    glEnable(GL_TEXTURE_2D);
+
+    // glAccum(GL_LOAD,0);
+    // if (bDarken==1)  glBlendFunc(GL_SRC_COLOR,GL_ZERO);
+
+    //Draw giant rectangle and texture it with our texture!
+    glBegin(GL_QUADS);
+    glTexCoord4d(0, 1,0,1); glVertex4d(-vw*.5,-vh*.5,-1,1);
+    glTexCoord4d(0, 0,0,1); glVertex4d(-vw*.5,  vh*.5,-1,1);
+    glTexCoord4d(1, 0,0,1); glVertex4d(vw*.5,  vh*.5,-1,1);
+    glTexCoord4d(1, 1,0,1); glVertex4d(vw*.5, -vh*.5,-1,1);
+    glEnd();
+
+    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+
+    //  if (bDarken==1)  glBlendFunc(GL_SRC_COLOR,GL_ONE_MINUS_SRC_ALPHA);
+
+    // if (bDarken==1) { glAccum(GL_ACCUM,1-fVideoEchoAlpha); glBlendFunc(GL_SRC_COLOR,GL_ZERO); }
+
+    glMatrixMode(GL_TEXTURE);
+
+    //draw video echo
+    glColor4f(0.0, 0.0, 0.0,fVideoEchoAlpha);
+    glTranslated(.5,.5,0);
+    glScaled(1/fVideoEchoZoom,1/fVideoEchoZoom,1);
+    glTranslated(-.5,-.5,0);
+
+    int flipx=1,flipy=1;
+    switch (((int)nVideoEchoOrientation))
+    {
+        case 0: flipx=1;flipy=1;break;
+        case 1: flipx=-1;flipy=1;break;
+        case 2: flipx=1;flipy=-1;break;
+        case 3: flipx=-1;flipy=-1;break;
+        default: flipx=1;flipy=1; break;
+    }
+    glBegin(GL_QUADS);
+    glTexCoord4d(0, 1,0,1); glVertex4f(-vw*.5*flipx,-vh*.5*flipy,-1,1);
+    glTexCoord4d(0, 0,0,1); glVertex4f(-vw*.5*flipx,  vh*.5*flipy,-1,1);
+    glTexCoord4d(1, 0,0,1); glVertex4f(vw*.5*flipx,  vh*.5*flipy,-1,1);
+    glTexCoord4d(1, 1,0,1); glVertex4f(vw*.5*flipx, -vh*.5*flipy,-1,1);
+    glEnd();
+
+
+    glDisable(GL_TEXTURE_2D);
+    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+
+    // if (bDarken==1) { glAccum(GL_ACCUM,fVideoEchoAlpha); glAccum(GL_RETURN,1);}
+
+    if (bInvert==1)
+    {
+        glColor4f(1.0, 1.0, 1.0,1.0);
+        glBlendFunc(GL_ONE_MINUS_DST_COLOR,GL_ZERO);
+        glBegin(GL_QUADS);
+        glVertex4f(-vw*.5*flipx,-vh*.5*flipy,-1,1);
+        glVertex4f(-vw*.5*flipx,  vh*.5*flipy,-1,1);
+        glVertex4f(vw*.5*flipx,  vh*.5*flipy,-1,1);
+        glVertex4f(vw*.5*flipx, -vh*.5*flipy,-1,1);
+        glEnd();
+        glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+    }
+}
+
+
+void render_texture_to_studio()
+{
+    glMatrixMode(GL_TEXTURE);
+    glLoadIdentity();
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    glTranslatef(0, 0, -9);
+
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,  GL_DECAL);
+    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
+
+    //       glClear(GL_ACCUM_BUFFER_BIT);
+    glColor4f(0.0, 0.0, 0.0,0.04);
+
+    glVertex4d(-vw*.5,-vh*.5,-1,1);
+    glVertex4d(-vw*.5,  vh*.5,-1,1);
+    glVertex4d(vw*.5,  vh*.5,-1,1);
+    glVertex4d(vw*.5, -vh*.5,-1,1);
+    glEnd();
+
+    glColor4f(0.0, 0.0, 0.0,1.0);
+
+    glBegin(GL_QUADS);
+    glVertex4d(-vw*.5,0,-1,1);
+    glVertex4d(-vw*.5,  vh*.5,-1,1);
+    glVertex4d(vw*.5,  vh*.5,-1,1);
+    glVertex4d(vw*.5, 0,-1,1);
+    glEnd();
+
+    glBegin(GL_QUADS);
+    glVertex4d(0,-vh*.5,-1,1);
+    glVertex4d(0,  vh*.5,-1,1);
+    glVertex4d(vw*.5,  vh*.5,-1,1);
+    glVertex4d(vw*.5, -vh*.5,-1,1);
+    glEnd();
+
+    glPushMatrix();
+    glTranslatef(.25*vw, .25*vh, 0);
+    glScalef(.5,.5,1);
+
+    //      glBindTexture( GL_TEXTURE_2D, tex2 );
+    glEnable(GL_TEXTURE_2D);
+
+    // glAccum(GL_LOAD,0);
+    // if (bDarken==1)  glBlendFunc(GL_SRC_COLOR,GL_ZERO);
+
+    //Draw giant rectangle and texture it with our texture!
+    glBegin(GL_QUADS);
+    glTexCoord4d(0, 1,0,1); glVertex4d(-vw*.5,-vh*.5,-1,1);
+    glTexCoord4d(0, 0,0,1); glVertex4d(-vw*.5,  vh*.5,-1,1);
+    glTexCoord4d(1, 0,0,1); glVertex4d(vw*.5,  vh*.5,-1,1);
+    glTexCoord4d(1, 1,0,1); glVertex4d(vw*.5, -vh*.5,-1,1);
+    glEnd();
+
+    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+
+    //  if (bDarken==1)  glBlendFunc(GL_SRC_COLOR,GL_ONE_MINUS_SRC_ALPHA);
+
+    // if (bDarken==1) { glAccum(GL_ACCUM,1-fVideoEchoAlpha); glBlendFunc(GL_SRC_COLOR,GL_ZERO); }
+
+    glMatrixMode(GL_TEXTURE);
+
+    //draw video echo
+    glColor4f(0.0, 0.0, 0.0,fVideoEchoAlpha);
+    glTranslated(.5,.5,0);
+    glScaled(1/fVideoEchoZoom,1/fVideoEchoZoom,1);
+    glTranslated(-.5,-.5,0);
+
+    int flipx=1,flipy=1;
+    switch (((int)nVideoEchoOrientation))
+    {
+        case 0: flipx=1;flipy=1;break;
+        case 1: flipx=-1;flipy=1;break;
+        case 2: flipx=1;flipy=-1;break;
+        case 3: flipx=-1;flipy=-1;break;
+        default: flipx=1;flipy=1; break;
+    }
+    glBegin(GL_QUADS);
+    glTexCoord4d(0, 1,0,1); glVertex4f(-vw*.5*flipx,-vh*.5*flipy,-1,1);
+    glTexCoord4d(0, 0,0,1); glVertex4f(-vw*.5*flipx,  vh*.5*flipy,-1,1);
+    glTexCoord4d(1, 0,0,1); glVertex4f(vw*.5*flipx,  vh*.5*flipy,-1,1);
+    glTexCoord4d(1, 1,0,1); glVertex4f(vw*.5*flipx, -vh*.5*flipy,-1,1);
+    glEnd();
+
+    glDisable(GL_TEXTURE_2D);
+    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+
+    // if (bDarken==1) { glAccum(GL_ACCUM,fVideoEchoAlpha); glAccum(GL_RETURN,1);}
+
+
+    if (bInvert==1)
+    {
+        glColor4f(1.0, 1.0, 1.0,1.0);
+        glBlendFunc(GL_ONE_MINUS_DST_COLOR,GL_ZERO);
+        glBegin(GL_QUADS);
+        glVertex4f(-vw*.5*flipx,-vh*.5*flipy,-1,1);
+        glVertex4f(-vw*.5*flipx,  vh*.5*flipy,-1,1);
+        glVertex4f(vw*.5*flipx,  vh*.5*flipy,-1,1);
+        glVertex4f(vw*.5*flipx, -vh*.5*flipy,-1,1);
+        glEnd();
+        glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+    }
+
+    //  glTranslated(.5,.5,0);
+    //  glScaled(1/fVideoEchoZoom,1/fVideoEchoZoom,1);
+    //   glTranslated(-.5,-.5,0);
+    //glTranslatef(0,.5*vh,0);
+
+    //per_pixel monitor
+    //glBlendFunc(GL_ONE_MINUS_DST_COLOR,GL_ZERO);
+    int x,y;
+    glMatrixMode(GL_MODELVIEW);
+    glPopMatrix();
+    glPushMatrix();
+    glTranslatef(.25*vw, -.25*vh, 0);
+    glScalef(.5,.5,1);
+    glColor4f(1,1,1,.6);
+
+    for (x=0;x<gx;x++)
+    {
+        glBegin(GL_LINE_STRIP);
+        for(y=0;y<gy;y++)
+        {
+            glVertex4f((x_mesh[x][y]-.5)* vw, (y_mesh[x][y]-.5)*vh,-1,1);
+            //glVertex4f((origx[x+1][y]-.5) * vw, (origy[x+1][y]-.5) *vh ,-1,1);
+        }
+        glEnd();
+    }
+
+    for (y=0;y<gy;y++)
+    {
+        glBegin(GL_LINE_STRIP);
+        for(x=0;x<gx;x++)
         {
-            glVertex2f( (float)j/256-1.0f, (float)p_data[0][j]/32000);
+            glVertex4f((x_mesh[x][y]-.5)* vw, (y_mesh[x][y]-.5)*vh,-1,1);
+            //glVertex4f((origx[x+1][y]-.5) * vw, (origy[x+1][y]-.5) *vh ,-1,1);
         }
+        glEnd();
+    }
+
+    /*
+       for (x=0;x<gx-1;x++){
+       glBegin(GL_POINTS);
+       for(y=0;y<gy;y++){
+       glVertex4f((origx[x][y]-.5)* vw, (origy[x][y]-.5)*vh,-1,1);
+       glVertex4f((origx[x+1][y]-.5) * vw, (origy[x+1][y]-.5) *vh ,-1,1);
+       }
+       glEnd();
+       }
+     */
+    // glTranslated(-.5,-.5,0);     glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+    glMatrixMode(GL_MODELVIEW);
+    glPopMatrix();
+    glPushMatrix();
+    glTranslatef(-.5*vw,0, 0);
+
+
+    glTranslatef(0,-vh*.10, 0);
+    glBegin(GL_LINE_STRIP);
+    glColor4f(0,1.0,1.0,1.0);
+    glVertex3f((((totalframes%256)/551.0))*vw, treb_att*-7,-1);
+    glColor4f(1.0,1.0,1.0,1.0);
+    glVertex3f((((totalframes%256)/551.0))*vw,0 ,-1);
+    glColor4f(.5,1.0,1.0,1.0);
+    glVertex3f((((totalframes%256)/551.0))*vw, treb*7,-1);
     glEnd();
 
-    galaktos_glx_swap( p_thread );
+    glTranslatef(0,-vh*.13, 0);
+    glBegin(GL_LINE_STRIP);
+    glColor4f(0,1.0,0.0,1.0);
+    glVertex3f((((totalframes%256)/551.0))*vw, mid_att*-7,-1);
+    glColor4f(1.0,1.0,1.0,1.0);
+    glVertex3f((((totalframes%256)/551.0))*vw,0 ,-1);
+    glColor4f(.5,1.0,0.0,0.5);
+    glVertex3f((((totalframes%256)/551.0))*vw, mid*7,-1);
+    glEnd();
 
-    return 0;
+    glTranslatef(0,-vh*.13, 0);
+    glBegin(GL_LINE_STRIP);
+    glColor4f(1.0,0.0,0.0,1.0);
+    glVertex3f((((totalframes%256)/551.0))*vw, bass_att*-7,-1);
+    glColor4f(1.0,1.0,1.0,1.0);
+    glVertex3f((((totalframes%256)/551.0))*vw,0 ,-1);
+    glColor4f(.7,0.2,0.2,1.0);
+    glVertex3f((((totalframes%256)/551.0))*vw, bass*7,-1);
+    glEnd();
+
+    glTranslatef(0,-vh*.13, 0);
+    glBegin(GL_LINES);
+
+    glColor4f(1.0,1.0,1.0,1.0);
+    glVertex3f((((totalframes%256)/551.0))*vw,0 ,-1);
+    glColor4f(1.0,0.6,1.0,1.0);
+    glVertex3f((((totalframes%256)/551.0))*vw, vol*7,-1);
+    glEnd();
+
+    glPopMatrix();
 }
 
 
index de7eb88..6d19742 100644 (file)
@@ -24,6 +24,8 @@
 #ifndef _GALAKTOS_MAIN_H_
 #define _GALAKTOS_MAIN_H_
 
-int galaktos_update( galaktos_thread_t *p_thread, int16_t p_data[2][512] );
+int galaktos_init( galaktos_thread_t *p_thread );
+void galaktos_done( galaktos_thread_t *p_thread );
+int galaktos_update( galaktos_thread_t *p_thread );
 
 #endif
diff --git a/modules/visualization/galaktos/param.c b/modules/visualization/galaktos/param.c
new file mode 100644 (file)
index 0000000..bf8f0e4
--- /dev/null
@@ -0,0 +1,721 @@
+/*****************************************************************************
+ * param.c:
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id$
+ *
+ * Authors: Cyril Deguet <asmax@videolan.org>
+ *          code from projectM http://xmms-projectm.sourceforge.net
+ *
+ * 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, USA.
+ *****************************************************************************/
+
+
+
+/* Basic Parameter Functions */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#include "fatal.h"
+#include "common.h"
+
+#include "splaytree_types.h"
+#include "splaytree.h"
+#include "tree_types.h"
+
+#include "param_types.h"
+#include "param.h"
+
+#include "expr_types.h"
+#include "eval.h"
+
+#include "engine_vars.h" 
+
+void reset_param(param_t * param);
+
+int is_valid_param_string(char * string); /* true if string is valid variable or function name */
+
+
+/* A splay tree of builtin parameters */
+splaytree_t * builtin_param_tree = NULL;
+
+int insert_param_alt_name(param_t * param, char * alt_name);
+
+int insert_builtin_param(param_t * param);
+
+/* Private function prototypes */
+int compare_param(char * name, char * name2);
+
+int load_builtin_param_double(char * name, void * engine_val, void * matrix, short int flags, 
+                                                               double init_val, double upper_bound, double lower_bound, char * alt_name);
+
+int load_builtin_param_int(char * name, void * engine_val, short int flags, 
+                                                               int init_val, int upper_bound, int lower_bound, char * alt_name);
+                                                               
+int load_builtin_param_bool(char * name, void * engine_val, short int flags, 
+                                                               int init_val, char * alt_name);
+                                                               
+                                                               
+                                                               
+param_t * create_param (char * name, short int type, short int flags, void * engine_val, void * matrix,
+                                                       value_t default_init_val, value_t upper_bound, value_t lower_bound) {
+
+  param_t * param = NULL;
+
+  param = (param_t*)malloc(sizeof(param_t));
+  if (param == NULL) {
+       printf("create_param: out of memory!!!\n");
+       return NULL;
+  }
+  
+  /* Clear name space, think the strncpy statement makes this redundant */
+  //memset(param->name, 0, MAX_TOKEN_SIZE);
+
+  /* Copy given name into parameter structure */
+  strncpy(param->name, name, MAX_TOKEN_SIZE-1); 
+  
+  /* Assign other entries in a constructor like fashion */
+  param->type = type;
+  param->flags = flags;
+  param->matrix_flag = 0;
+  param->matrix = matrix;
+  param->engine_val = engine_val;
+  param->default_init_val = default_init_val;
+  //*param->init_val = default_init_val;
+  param->upper_bound = upper_bound;
+  param->lower_bound = lower_bound;
+  
+  /* Return instantiated parameter */
+  return param;
+
+}
+
+/* Creates a user defined parameter */
+param_t * create_user_param(char * name) {
+
+  param_t * param;
+  value_t iv;
+  value_t ub;
+  value_t lb;
+  double * engine_val;
+  
+  /* Set initial values to default */
+  iv.double_val = DEFAULT_DOUBLE_IV;
+  ub.double_val = DEFAULT_DOUBLE_UB;
+  lb.double_val = DEFAULT_DOUBLE_LB;
+
+  /* Argument checks */
+  if (name == NULL)
+    return NULL;
+
+  /* Allocate space for the engine variable */
+  if ((engine_val = (double*)malloc(sizeof(double))) == NULL)
+    return NULL;
+
+  (*engine_val) = iv.double_val; /* set some default init value */
+  
+  /* Create the new user parameter */
+  if ((param = create_param(name, P_TYPE_DOUBLE, P_FLAG_USERDEF, engine_val, NULL, iv, ub, lb)) == NULL) {
+    free(engine_val);
+    return NULL;
+  }
+  if (PARAM_DEBUG) printf("create_param: \"%s\" initialized\n", param->name);
+  /* Return the instantiated parameter */
+  return param;
+}
+
+/* Initialize the builtin parameter database.
+   Should only be necessary once */
+int init_builtin_param_db() {
+       
+  /* Create the builtin parameter splay tree (go Sleator...) */
+  if ((builtin_param_tree = create_splaytree(compare_string, copy_string, free_string)) == NULL) {
+         if (PARAM_DEBUG) printf("init_builtin_param_db: failed to initialize database (FATAL)\n");  
+         return OUTOFMEM_ERROR;
+  } 
+
+  if (PARAM_DEBUG) {
+         printf("init_builtin_param: loading database...");
+         fflush(stdout);
+  }
+  
+  /* Loads all builtin parameters into the database */
+  if (load_all_builtin_param() < 0) {
+       if (PARAM_DEBUG) printf("failed loading builtin parameters (FATAL)\n");
+    return ERROR;
+  }
+  
+  if (PARAM_DEBUG) printf("success!\n");
+         
+  /* Finished, no errors */
+  return SUCCESS;
+}
+
+/* Destroy the builtin parameter database.
+   Generally, do this on projectm exit */
+int destroy_builtin_param_db() {
+  
+  splay_traverse(free_param, builtin_param_tree);
+  destroy_splaytree(builtin_param_tree);
+  builtin_param_tree = NULL;
+  return SUCCESS;      
+
+}
+
+
+/* Insert a parameter into the database with an alternate name */
+int insert_param_alt_name(param_t * param, char * alt_name) {
+  
+  if (param == NULL)
+    return ERROR;
+  if (alt_name == NULL)
+         return ERROR;
+       
+  splay_insert_link(alt_name, param->name, builtin_param_tree);
+
+  return SUCCESS;
+}
+
+
+param_t * find_builtin_param(char * name) {
+
+  /* Null argument checks */
+  if (name == NULL)
+         return NULL;
+    
+  return splay_find(name, builtin_param_tree);
+
+}
+
+/* Find a parameter given its name, will create one if not found */
+param_t * find_param(char * name, preset_t * preset, int flags) {
+
+  param_t * param = NULL;
+
+  /* Null argument checks */
+  if (name == NULL)
+         return NULL;
+  if (preset == NULL)
+         return NULL;
+  
+  /* First look in the builtin database */
+  param = (param_t *)splay_find(name, builtin_param_tree);
+
+  /* If the search failed, check the user database */
+  if (param == NULL) {
+    param = (param_t*)splay_find(name, preset->user_param_tree);
+  }
+  /* If it doesn't exist in the user (or builtin) database and 
+         create_flag is set, then make it and insert into the database 
+  */
+  
+  if ((param == NULL) && (flags & P_CREATE)) {
+       
+       /* Check if string is valid */
+    if (!is_valid_param_string(name)) {
+      if (PARAM_DEBUG) printf("find_param: invalid parameter name:\"%s\"\n", name);
+      return NULL;
+    }
+    /* Now, create the user defined parameter given the passed name */
+    if ((param = create_user_param(name)) == NULL) {
+      if (PARAM_DEBUG) printf("find_param: failed to create a new user parameter!\n");
+      return NULL;
+    }
+    /* Finally, insert the new parameter into this preset's proper splaytree */
+    if (splay_insert(param, param->name, preset->user_param_tree) < 0) {
+      if (PARAM_DEBUG) printf("PARAM \"%s\" already exists in user parameter tree!\n", param->name);
+      free_param(param);
+      return NULL;
+    }   
+    
+  }      
+  
+  /* Return the found (or created) parameter. Note that if P_CREATE is not set, this could be null */
+  return param;
+  
+}
+
+/* Compare string name with parameter name */
+int compare_param(char * name, char * name2) {
+
+  int cmpval;
+  printf("am i used\n");
+  /* Uses string comparison function */
+  cmpval = strncmp(name, name2, MAX_TOKEN_SIZE-1);
+  
+  return cmpval;
+}
+
+/* Loads all builtin parameters, limits are also defined here */
+int load_all_builtin_param() {
+
+  load_builtin_param_double("fRating", (void*)&fRating, NULL, P_FLAG_NONE, 0.0 , 5.0, 0.0, NULL);
+  load_builtin_param_double("fWaveScale", (void*)&fWaveScale, NULL, P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+  load_builtin_param_double("gamma", (void*)&fGammaAdj, NULL, P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, 0, "fGammaAdj");
+  load_builtin_param_double("echo_zoom", (void*)&fVideoEchoZoom, NULL, P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, 0, "fVideoEchoZoom");
+  load_builtin_param_double("echo_alpha", (void*)&fVideoEchoAlpha, NULL, P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, 0, "fVideoEchoAlpha");
+  load_builtin_param_double("wave_a", (void*)&fWaveAlpha, NULL, P_FLAG_NONE, 0.0, 1.0, 0, "fWaveAlpha");
+  load_builtin_param_double("fWaveSmoothing", (void*)&fWaveSmoothing, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);  
+  load_builtin_param_double("fModWaveAlphaStart", (void*)&fModWaveAlphaStart, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
+  load_builtin_param_double("fModWaveAlphaEnd", (void*)&fModWaveAlphaEnd, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
+  load_builtin_param_double("fWarpAnimSpeed",  (void*)&fWarpAnimSpeed, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
+  //  load_builtin_param_double("warp", (void*)&warp, warp_mesh, P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
+       
+  load_builtin_param_double("fShader", (void*)&fShader, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
+  load_builtin_param_double("decay", (void*)&decay, NULL, P_FLAG_NONE, 0.0, 1.0, 0, "fDecay");
+
+  load_builtin_param_int("echo_orient", (void*)&nVideoEchoOrientation, P_FLAG_NONE, 0, 3, 0, "nVideoEchoOrientation");
+  load_builtin_param_int("wave_mode", (void*)&nWaveMode, P_FLAG_NONE, 0, 7, 0, "nWaveMode");
+  
+  load_builtin_param_bool("wave_additive", (void*)&bAdditiveWaves, P_FLAG_NONE, FALSE, "bAdditiveWaves");
+  load_builtin_param_bool("bModWaveAlphaByVolume", (void*)&bModWaveAlphaByVolume, P_FLAG_NONE, FALSE, NULL);
+  load_builtin_param_bool("wave_brighten", (void*)&bMaximizeWaveColor, P_FLAG_NONE, FALSE, "bMaximizeWaveColor");
+  load_builtin_param_bool("wrap", (void*)&bTexWrap, P_FLAG_NONE, FALSE, "bTexWrap");
+  load_builtin_param_bool("darken_center", (void*)&bDarkenCenter, P_FLAG_NONE, FALSE, "bDarkenCenter");
+  load_builtin_param_bool("bRedBlueStereo", (void*)&bRedBlueStereo, P_FLAG_NONE, FALSE, NULL);
+  load_builtin_param_bool("brighten", (void*)&bBrighten, P_FLAG_NONE, FALSE, "bBrighten");
+  load_builtin_param_bool("darken", (void*)&bDarken, P_FLAG_NONE, FALSE, "bDarken");
+  load_builtin_param_bool("solarize", (void*)&bSolarize, P_FLAG_NONE, FALSE, "bSolarize");
+  load_builtin_param_bool("invert", (void*)&bInvert, P_FLAG_NONE, FALSE, "bInvert");
+  load_builtin_param_bool("bMotionVectorsOn", (void*)&bMotionVectorsOn, P_FLAG_NONE, FALSE, NULL);
+  load_builtin_param_bool("wave_dots", (void*)&bWaveDots, P_FLAG_NONE, FALSE, "bWaveDots");
+  load_builtin_param_bool("wave_thick", (void*)&bWaveThick, P_FLAG_NONE, FALSE, "bWaveThick");
+  
+  
+  load_builtin_param_double("zoom", (void*)&zoom, zoom_mesh,  P_FLAG_PER_PIXEL |P_FLAG_DONT_FREE_MATRIX, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
+  load_builtin_param_double("rot", (void*)&rot, rot_mesh,  P_FLAG_PER_PIXEL |P_FLAG_DONT_FREE_MATRIX, 0.0, MAX_DOUBLE_SIZE, MIN_DOUBLE_SIZE, NULL);
+  load_builtin_param_double("zoomexp", (void*)&zoomexp, zoomexp_mesh,  P_FLAG_PER_PIXEL |P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, 0, "fZoomExponent");
+  load_builtin_param_double("cx", (void*)&cx, cx_mesh, P_FLAG_PER_PIXEL | P_FLAG_DONT_FREE_MATRIX, 0.0, 1.0, 0, NULL);
+  load_builtin_param_double("cy", (void*)&cy, cy_mesh, P_FLAG_PER_PIXEL | P_FLAG_DONT_FREE_MATRIX, 0.0, 1.0, 0, NULL);
+  load_builtin_param_double("dx", (void*)&dx, dx_mesh,  P_FLAG_PER_PIXEL | P_FLAG_DONT_FREE_MATRIX, 0.0, MAX_DOUBLE_SIZE, MIN_DOUBLE_SIZE, NULL);
+  load_builtin_param_double("dy", (void*)&dy, dy_mesh,  P_FLAG_PER_PIXEL |P_FLAG_DONT_FREE_MATRIX, 0.0, MAX_DOUBLE_SIZE, MIN_DOUBLE_SIZE, NULL);
+  load_builtin_param_double("sx", (void*)&sx, sx_mesh,  P_FLAG_PER_PIXEL |P_FLAG_DONT_FREE_MATRIX, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
+  load_builtin_param_double("sy", (void*)&sy, sy_mesh,  P_FLAG_PER_PIXEL |P_FLAG_DONT_FREE_MATRIX, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
+
+  load_builtin_param_double("wave_r", (void*)&wave_r, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+  load_builtin_param_double("wave_g", (void*)&wave_g, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+  load_builtin_param_double("wave_b", (void*)&wave_b, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+  load_builtin_param_double("wave_x", (void*)&wave_x, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+  load_builtin_param_double("wave_y", (void*)&wave_y, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+  load_builtin_param_double("wave_mystery", (void*)&wave_mystery, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, "fWaveParam");
+  
+  load_builtin_param_double("ob_size", (void*)&ob_size, NULL, P_FLAG_NONE, 0.0, 0.5, 0, NULL);
+  load_builtin_param_double("ob_r", (void*)&ob_r, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+  load_builtin_param_double("ob_g", (void*)&ob_g, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+  load_builtin_param_double("ob_b", (void*)&ob_b, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+  load_builtin_param_double("ob_a", (void*)&ob_a, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+
+  load_builtin_param_double("ib_size", (void*)&ib_size,  NULL,P_FLAG_NONE, 0.0, .5, 0.0, NULL);
+  load_builtin_param_double("ib_r", (void*)&ib_r,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+  load_builtin_param_double("ib_g", (void*)&ib_g,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+  load_builtin_param_double("ib_b", (void*)&ib_b,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+  load_builtin_param_double("ib_a", (void*)&ib_a,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+
+  load_builtin_param_double("mv_r", (void*)&mv_r,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+  load_builtin_param_double("mv_g", (void*)&mv_g,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+  load_builtin_param_double("mv_b", (void*)&mv_b,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+  load_builtin_param_double("mv_x", (void*)&mv_x,  NULL,P_FLAG_NONE, 0.0, 64.0, 0.0, "nMotionVectorsX");
+  load_builtin_param_double("mv_y", (void*)&mv_y,  NULL,P_FLAG_NONE, 0.0, 48.0, 0.0, "nMotionVectorsY");
+  load_builtin_param_double("mv_l", (void*)&mv_l,  NULL,P_FLAG_NONE, 0.0, 5.0, 0.0, NULL);
+  load_builtin_param_double("mv_dy", (void*)&mv_dy, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
+  load_builtin_param_double("mv_dx", (void*)&mv_dx,  NULL,P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
+  load_builtin_param_double("mv_a", (void*)&mv_a,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
+
+  load_builtin_param_double("time", (void*)&Time,  NULL,P_FLAG_READONLY, 0.0, MAX_DOUBLE_SIZE, 0.0, NULL);        
+  load_builtin_param_double("bass", (void*)&bass,  NULL,P_FLAG_READONLY, 0.0, MAX_DOUBLE_SIZE, 0.0, NULL);
+  load_builtin_param_double("mid", (void*)&mid,  NULL,P_FLAG_READONLY, 0.0, MAX_DOUBLE_SIZE, 0, NULL);      
+  load_builtin_param_double("bass_att", (void*)&bass_att,  NULL,P_FLAG_READONLY, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
+  load_builtin_param_double("mid_att", (void*)&mid_att,  NULL,P_FLAG_READONLY, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
+  load_builtin_param_double("treb_att", (void*)&treb_att,  NULL,P_FLAG_READONLY, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
+  load_builtin_param_int("frame", (void*)&frame, P_FLAG_READONLY, 0, MAX_INT_SIZE, 0, NULL);
+  load_builtin_param_double("progress", (void*)&progress,  NULL,P_FLAG_READONLY, 0.0, 1, 0, NULL);
+  load_builtin_param_int("fps", (void*)&fps, P_FLAG_NONE, 15, MAX_INT_SIZE, 0, NULL);
+
+
+
+  load_builtin_param_double("x", (void*)&x_per_pixel, x_mesh,  P_FLAG_PER_PIXEL |P_FLAG_ALWAYS_MATRIX | P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX, 
+                           0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+  load_builtin_param_double("y", (void*)&y_per_pixel, y_mesh,  P_FLAG_PER_PIXEL |P_FLAG_ALWAYS_MATRIX |P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX, 
+                           0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+  load_builtin_param_double("ang", (void*)&ang_per_pixel, theta_mesh,  P_FLAG_PER_PIXEL |P_FLAG_ALWAYS_MATRIX | P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX, 
+                           0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);      
+  load_builtin_param_double("rad", (void*)&rad_per_pixel, rad_mesh,  P_FLAG_PER_PIXEL |P_FLAG_ALWAYS_MATRIX | P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX, 
+                           0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+
+
+  load_builtin_param_double("q1", (void*)&q1,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+  load_builtin_param_double("q2", (void*)&q2,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+  load_builtin_param_double("q3", (void*)&q3,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+  load_builtin_param_double("q4", (void*)&q4,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+  load_builtin_param_double("q5", (void*)&q5,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+  load_builtin_param_double("q6", (void*)&q6,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+  load_builtin_param_double("q7", (void*)&q7,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+  load_builtin_param_double("q8", (void*)&q8,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+
+
+
+  /* variables added in 1.04 */
+  load_builtin_param_int("meshx", (void*)&gx, P_FLAG_READONLY, 32, 96, 8, NULL);
+  load_builtin_param_int("meshy", (void*)&gy, P_FLAG_READONLY, 24, 72, 6, NULL);
+
+  return SUCCESS;  
+  
+}
+
+/* Free's a parameter type */
+void free_param(param_t * param) {
+  int x;
+  if (param == NULL)
+       return;
+  
+  if (param->flags & P_FLAG_USERDEF) {
+    free(param->engine_val);
+
+  }
+
+  if (!(param->flags & P_FLAG_DONT_FREE_MATRIX)) {
+
+    if (param->flags & P_FLAG_PER_POINT)
+      free(param->matrix);
+
+    else if (param->flags & P_FLAG_PER_PIXEL) {
+       for(x = 0; x < gx; x++) 
+          free(((double**)param->matrix)[x]);
+       free(param->matrix);
+      }
+  }
+
+  if (PARAM_DEBUG) printf("free_param: freeing \"%s\".\n", param->name);
+  free(param);
+
+}
+
+/* Loads a double parameter into the builtin database */
+int load_builtin_param_double(char * name, void * engine_val, void * matrix, short int flags, 
+                                               double init_val, double upper_bound, double lower_bound, char * alt_name) {
+
+  param_t * param = NULL;
+  value_t iv, ub, lb;
+
+  iv.double_val = init_val;
+  ub.double_val = upper_bound;
+  lb.double_val = lower_bound;
+                                                       
+  /* Create new parameter of type double */
+  if (PARAM_DEBUG == 2) {
+         printf("load_builtin_param_double: (name \"%s\") (alt_name = \"%s\") ", name, alt_name);
+         fflush(stdout);
+  }  
+  
+ if ((param = create_param(name, P_TYPE_DOUBLE, flags, engine_val, matrix, iv, ub, lb)) == NULL) {
+    return OUTOFMEM_ERROR;
+  }
+  
+  if (PARAM_DEBUG == 2) {
+       printf("created...");
+       fflush(stdout);
+   }     
+   
+  /* Insert the paremeter into the database */
+
+  if (insert_builtin_param(param) < 0) {
+       free_param(param);
+    return ERROR;
+  }
+
+  if (PARAM_DEBUG == 2) {
+         printf("inserted...");
+         fflush(stdout);
+  }  
+  
+  /* If this parameter has an alternate name, insert it into the database as link */
+  
+  if (alt_name != NULL) {
+       insert_param_alt_name(param, alt_name); 
+
+  if (PARAM_DEBUG == 2) {
+         printf("alt_name inserted...");
+         fflush(stdout);
+       }
+  
+       
+  }      
+
+  if (PARAM_DEBUG == 2) printf("finished\n");    
+  /* Finished, return success */
+  return SUCCESS;
+}
+
+
+
+/* Loads a double parameter into the builtin database */
+param_t * new_param_double(char * name, short int flags, void * engine_val, void * matrix,
+                                               double upper_bound, double lower_bound, double init_val) {
+
+  param_t * param;
+  value_t iv, ub, lb;
+
+  iv.double_val = init_val;
+  ub.double_val = upper_bound;
+  lb.double_val = lower_bound;
+                                               
+  if ((param = create_param(name, P_TYPE_DOUBLE, flags, engine_val, matrix,iv, ub, lb)) == NULL) 
+    return NULL;
+  
+  
+  /* Finished, return success */
+  return param;
+}
+
+
+/* Creates a new parameter of type int */
+param_t * new_param_int(char * name, short int flags, void * engine_val,
+                                               int upper_bound, int lower_bound, int init_val) {
+
+  param_t * param;
+  value_t iv, ub, lb;
+
+  iv.int_val = init_val;
+  ub.int_val = upper_bound;
+  lb.int_val = lower_bound;
+                                                       
+  if ((param = create_param(name, P_TYPE_INT, flags, engine_val, NULL, iv, ub, lb)) == NULL) 
+    return NULL;
+  
+  /* Finished, return success */
+  return param;
+}
+
+/* Creates a new parameter of type bool */
+param_t * new_param_bool(char * name, short int flags, void * engine_val,
+                                               int upper_bound, int lower_bound, int init_val) {
+
+  param_t * param;
+  value_t iv, ub, lb;
+
+  iv.bool_val = init_val;
+  ub.bool_val = upper_bound;
+  lb.bool_val = lower_bound;
+                                                       
+  if ((param = create_param(name, P_TYPE_BOOL, flags, engine_val, NULL, iv, ub, lb)) == NULL)
+    return NULL;
+  
+  /* Finished, return success */
+  return param;
+}
+
+
+/* Loads a integer parameter into the builtin database */
+int load_builtin_param_int(char * name, void * engine_val, short int flags,
+                                               int init_val, int upper_bound, int lower_bound, char * alt_name) {
+
+  param_t * param;
+  value_t iv, ub, lb;
+
+  iv.int_val = init_val;
+  ub.int_val = upper_bound;
+  lb.int_val = lower_bound;    
+                                                       
+  param = create_param(name, P_TYPE_INT, flags, engine_val, NULL, iv, ub, lb);
+
+  if (param == NULL) {
+    return OUTOFMEM_ERROR;
+  }
+
+  if (insert_builtin_param(param) < 0) {
+       free_param(param);
+    return ERROR;
+  }
+  
+  if (alt_name != NULL) {
+       insert_param_alt_name(param, alt_name);          
+  }  
+  
+  return SUCCESS;
+
+}                                                      
+                                                       
+/* Loads a boolean parameter */
+int load_builtin_param_bool(char * name, void * engine_val, short int flags, 
+                                                               int init_val, char * alt_name) {
+
+  param_t * param;
+  value_t iv, ub, lb;
+
+  iv.int_val = init_val;
+  ub.int_val = TRUE;
+  lb.int_val = FALSE;  
+                                                                                                                               
+  param = create_param(name, P_TYPE_BOOL, flags, engine_val, NULL, iv, ub, lb);
+
+  if (param == NULL) {
+    return OUTOFMEM_ERROR;
+  }
+
+  if (insert_builtin_param(param) < 0) {
+       free_param(param);
+    return ERROR;
+  }
+  
+  if (alt_name != NULL) {
+       insert_param_alt_name(param, alt_name);          
+  }  
+  
+  return SUCCESS;
+
+}
+
+
+       
+
+/* Returns nonzero if the string is valid parameter name */
+int is_valid_param_string(char * string) {
+  
+  if (string == NULL)
+    return FALSE;
+  
+  /* This ensures the first character is non numeric */
+  if( ((*string) >= 48) && ((*string) <= 57))
+    return FALSE; 
+
+  /* These probably should never happen */
+  if (*string == '.')
+       return FALSE;
+  
+  if (*string == '+')
+       return FALSE;
+  
+  if (*string == '-')
+       return FALSE;
+  
+  /* Could also add checks for other symbols. May do later */
+  
+  return TRUE;
+   
+}
+
+/* Inserts a parameter into the builtin database */
+int insert_builtin_param(param_t * param) {
+
+       if (param == NULL)
+               return FAILURE;
+       
+       return splay_insert(param, param->name, builtin_param_tree);    
+}
+
+/* Inserts a parameter into the builtin database */
+int insert_param(param_t * param, splaytree_t * database) {
+
+       if (param == NULL)
+         return FAILURE;
+       if (database == NULL)
+         return FAILURE;
+
+       return splay_insert(param, param->name, database);      
+}
+
+
+/* Sets the parameter engine value to value val.
+       clipping occurs if necessary */
+void set_param(param_t * param, double val) {
+
+       switch (param->type) {
+               
+       case P_TYPE_BOOL:
+               if (val < 0)
+                       *((int*)param->engine_val) = 0;
+               else if (val > 0)
+                       *((int*)param->engine_val) = 1;
+               else
+                       *((int*)param->engine_val) = 0;
+               break;
+       case P_TYPE_INT:
+               /* Make sure value is an integer */
+               val = floor(val);
+               if (val < param->lower_bound.int_val)
+                               *((int*)param->engine_val) = param->lower_bound.int_val;
+               else if (val > param->upper_bound.int_val)
+                               *((int*)param->engine_val) = param->upper_bound.int_val;
+               else
+                               *((int*)param->engine_val) = val;
+               break;
+       case P_TYPE_DOUBLE:
+         /* Make sure value is an integer */   
+
+        
+         if (val < param->lower_bound.double_val) 
+           *((double*)param->engine_val) = param->lower_bound.double_val;        
+         else if (val > param->upper_bound.double_val)
+           *((double*)param->engine_val) = param->upper_bound.double_val;
+         else
+           *((double*)param->engine_val) = val;
+         break;
+       default:
+         break;
+
+       }
+       
+       return;
+}
+
+
+
+
+/* Search for parameter 'name' in 'database', if create_flag is true, then generate the parameter 
+   and insert it into 'database' */
+param_t * find_param_db(char * name, splaytree_t * database, int create_flag) {
+
+  param_t * param = NULL;
+
+  /* Null argument checks */
+  if (name == NULL)
+    return NULL;
+  if (database == NULL)
+    return NULL;
+  
+  /* First look in the builtin database */
+  param = (param_t *)splay_find(name, database);
+
+  
+  if (((param = (param_t *)splay_find(name, database)) == NULL) && (create_flag == TRUE)) {
+       
+       /* Check if string is valid */
+       if (!is_valid_param_string(name))
+               return NULL;
+       
+       /* Now, create the user defined parameter given the passed name */
+       if ((param = create_user_param(name)) == NULL)
+               return NULL;
+       
+       /* Finally, insert the new parameter into this preset's proper splaytree */
+       if (splay_insert(param, param->name, database) < 0) {
+               free_param(param);
+               return NULL;
+       }        
+       
+  }      
+  
+  /* Return the found (or created) parameter. Note that this could be null */
+  return param;
+
+}
+
diff --git a/modules/visualization/galaktos/param.h b/modules/visualization/galaktos/param.h
new file mode 100644 (file)
index 0000000..1fc6713
--- /dev/null
@@ -0,0 +1,36 @@
+#ifndef PARAM_H
+#define PARAM_H
+#include "preset_types.h"
+#include "splaytree_types.h"
+/* Debug level, zero for none */
+#define PARAM_DEBUG 0
+
+/* Used to store a number of decidable type */
+
+/* Function prototypes */
+param_t * create_param (char * name, short int type, short int flags, void * eqn_val, void * matrix,
+                                                       value_t default_init_val, value_t upper_bound, value_t lower_bound);
+param_t * create_user_param(char * name);
+int init_builtin_param_db();
+int init_user_param_db();
+int destroy_user_param_db();
+int destroy_builtin_param_db();
+void set_param(param_t * param, double val);
+int remove_param(param_t * param);
+param_t * find_param(char * name, struct PRESET_T * preset, int flags);
+void free_param(param_t * param);
+int load_all_builtin_param();
+int insert_param(param_t * param, splaytree_t * database);
+param_t * find_builtin_param(char * name);
+param_t * new_param_double(char * name, short int flags, void * engine_val, void * matrix,
+                       double upper_bound, double lower_bound, double init_val);
+
+param_t * new_param_int(char * name, short int flags, void * engine_val,
+                       int upper_bound, int lower_bound, int init_val);
+
+param_t *&