/*
  disco.c - flash X keyboard lights in disco effect from esd, ats@offog.org

  Based on Raster's extace hack.
*/

#include <stdio.h>
#include <math.h>
#include <esd.h>
#include <rfftw.h>
#include <glib.h>
#include <X11/Xos.h>
#include <X11/Xfuncs.h>
#include <X11/Xlib.h>
#include <X11/keysym.h>
#include <X11/Xproto.h>
#include <X11/Xutil.h>
#include <X11/Xmu/Error.h>
#include <X11/XKBlib.h>

#define SIZE 1024
#define BANDS 30

#define LOG		0x800000
#define LINEAR		0x1000000
#define WINDOW_FUNC  3 /* 3 is the default */

#define LIGHTS 3
gint lights[LIGHTS]         = { 3,    15,    25  };
double triggerlevel[LIGHTS] = { 10.0, 10.0, 1.0 };

short audio[SIZE];

gint 	      bands=BANDS;	// to start with, should be configurable
double         audata[SIZE]; // (x2 ?? )
double         auout[SIZE];
double         audata_backup[SIZE];
double         aufft[SIZE];
guint          auval[SIZE];
gint           sound;
float scale;
gint  scalefixed=0;	// its NOT fixed YET. (done dynamically)
gint  sensefixed=0;	// its NOT fixed YET. (done dynamically)
float scalefactor=10.0; 	// dynamically figured out by the program
double levels[BANDS];
double        *datawindow;
double         datawindowsum;
gint window_func=WINDOW_FUNC;
gint bands_per_block;
gint sensitivity=240;	// Brightness sensitivity, so the colortable
gint axis_type=LOG;
fftw_plan plan;                 // fft plan for fftw library

void setup_datawindow(void)
{
    gint i;
    gdouble *val;
    gdouble sumw;
    gint fftlen = SIZE/2;
    gint alpha = 1;

    val = g_malloc(SIZE*sizeof(double));

    for(i=0;i<fftlen;i++)
    {
	switch(window_func)
	{
	    case 1:    /* Hanning */
		val[i] = 0.5 - 0.5*cos(2*M_PI*i/fftlen);
		break;

	    case 2:    /* Blackman */
		val[i] = 0.42-0.5*cos(2*M_PI*i/fftlen)+0.08*cos(4*M_PI*i/fftlen);
		break;

	    case 3:    /* Gaussian */
		val[i] = exp(-alpha / ((double)fftlen*(double)fftlen)
			    * ((double)2*i-fftlen)*((double)2*i-fftlen));
		break;
	    case 4:    /* Welch */
		val[i] = 1 -  ((double)(2*i-fftlen)/(double)(fftlen+1))
			    * ((double)(2*i-fftlen)/(double)(fftlen+1));
		break;

	    case 5:    /* Parzen */
		val[i] = 1 - fabs((double)(2*i-fftlen)/(double)(fftlen+1));
		break;

	    case 6:    /* Rectangular */
		val[i] = 1.0;
		break;

	    default:   /* Hamming */
		val[i] = 0.54-0.46*cos(2*M_PI*i/fftlen);
		break;
	}
	sumw += val[i];
    }
	datawindow = val;
	datawindowsum = sumw;

}

int GetFFT(void)
{
    short *ptr;
    double *w,*aup,*aup2,*fftp,*aupend;

	ptr=audio;
	w=datawindow;
	aup=audata;
	aupend=aup+SIZE;
	while(aup<aupend)
	    *aup++=((*w++)*(double)(*ptr++))/32768.0;
    ptr=audio;
    aup=audata_backup;
    aupend=aup+SIZE;
    while(aup<aupend)
	*aup++=((double)(*ptr++))/32768.0;

    rfftw_one(plan, audata, auout);
    aufft[0] = (auout[0]*auout[0])/(SIZE*SIZE);
    aufft[SIZE/2] = (auout[SIZE/2]*auout[SIZE/2])/(SIZE*SIZE);
    /* take the log */
    aup=auout;
    aup2=auout+SIZE-1;


    aupend=aup+SIZE;
    fftp=aufft;
    while(aup<aupend)
    {
	*fftp=8+log10((((*aup * *aup)+(*aup2 * *aup2)))/(SIZE*SIZE));
	if (*fftp<0) *fftp=0;
	fftp++;
	aup++;aup2--;
    }
    return 1;
}

int main(int argc, char **argv) {
  gint i,j,k;
  int sum;
  int count;
  static gint log_x_axis[BANDS];
  double val;
  Display *dpy;
  Atom myatom;
  int event, error, reason;

  if (!(dpy=XkbOpenDisplay(NULL, &event, &error, NULL, NULL, &reason))) return 20;

  setup_datawindow();
  sound = esd_monitor_stream(ESD_BITS16|ESD_MONO|ESD_STREAM|ESD_PLAY,44100,NULL,"disco");
  if (sound<0) return 20;
  plan = rfftw_create_plan(SIZE, FFTW_FORWARD, FFTW_ESTIMATE);
  printf("%c[H%c[2J", 27, 27);

  while (1) {
    read(sound, audio, SIZE);
    GetFFT();

    if (scalefixed == 0) {
      scalefactor = 10.0;
      
      count = 0;
    recalc:
      count++;
      scale = bands/scalefactor;
      sum = 0;
      for (i=0; i < bands ; i++) {
	log_x_axis[i] = exp((i/scale));
	sum = sum + log_x_axis[i];
      }
      if (sum > SIZE/2)  {
	if (sum > (2.0*(SIZE/2)))
	  scalefactor = scalefactor - .80;
	if (sum > (1.25*(SIZE/2)))
	  scalefactor = scalefactor - .150;
	if (sum > (1.15*(SIZE/2)))
	  scalefactor = scalefactor - .025;
	if (sum > (1.05*(SIZE/2)))
	  scalefactor = scalefactor - .009;
	if (sum < (1.05*(SIZE/2)))
	  scalefactor = scalefactor - .001;
	goto recalc;
      }
    }
    scalefixed = 1;
    
    for (i=1; i<SIZE/2; i++)
      auval[i-1] = (aufft[i]/20)*(double)datawindow[i-1]*(double)sensitivity;
    auval[(SIZE/2)-1]=0;
    
    j=0;
    k=0;
    bands_per_block = floor((SIZE/2)/bands);
    for(i=0;i<bands;i++) {
      val=0;
      // sum it then average it so the scaling doesn't go haywire
      switch (axis_type) {
      case (LOG):
	for(j=0;j<(log_x_axis[i]);j++)
	  {val+=auval[k++];}
	val/=(double)log_x_axis[i];
	break;
      case (LINEAR):
	for(j=0;j<bands_per_block;j++)
	  {val+=auval[k++];}
	val/=(double)bands_per_block;
	break;
      }
      
      levels[i]=val;
    } /* for bands */

    /* "Caps Lock", "Scroll Lock", "Num Lock", "Shift Lock" */
    for (i=0; i<LIGHTS; i++) {
      printf("%c ", (levels[lights[i]] > triggerlevel[i]) ? '#' : ' ');
      /*myatom = XInternAtom(dpy, "Num Lock", False);
      XkbSetNamedIndicator(dpy, myatom, True, (levels[lights[i]]>triggerlevel[i]) ? True : False, False, False);*/
    }
    printf("\r"); fflush(stdout);

/*    putchar(27);putchar('[');putchar('H');
    for (i=0; i<BANDS; i++) {
      j=levels[i];
      printf("%3d %3d ",i,j);
      while(j--) putchar('-');
      j=100-levels[i];
      while(j--) putchar(' ');
      putchar('\n');
    }
    fflush(stdout); */

  } /* while(1) */
}