// ZPlane Viewer for ResoLab1 (one biquad)
// Original code, 1988-1991, in Objective C for NeXTStep
// This port to Open GL, 2005

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

char file_name[256];

#define X_MAX 640.0
#define Y_MAX 180.0

#define PI 3.141592654782
#define SQRT_TWO 1.414213562
#define TWO_PI 6.283185309564
#define SRATE 44100.0

int numStrings = 0;
int notDone = 1;
int outOne = 0;
char **inputString;

int myWin;

// The input command pipe and socket threads are defined here.
#include "threads.h"

unsigned long string_thread;

float params[4] = {0.0, 0.0, 0.0, 0.0};
float incoeffs[2],outcoeffs[2];

#define STRING_LEN 1024
#define MAX_IN_STRINGS 64

void newStringByPipe(void)	{
  extern int numStrings, notDone;
  extern char **inputString;
  int i,gotOne;

  // Malloc inputString.
  inputString = (char **) malloc(MAX_IN_STRINGS * sizeof(char *));
  for ( i=0;i<MAX_IN_STRINGS;i++ )
    inputString[i] = (char *) malloc(STRING_LEN * sizeof(char));

  int inOne = 0;
  while (notDone) {
    fgets(inputString[inOne],STRING_LEN,stdin);
	if (inputString[inOne][2] == 'i' && inputString[inOne][3] == 't'
        	&& inputString[inOne][1] == 'x' && inputString[inOne][0] == 'E') {
      		notDone = 0;
       		printf("Done ZPlaning!!\n");
		for ( i=0;i<MAX_IN_STRINGS;i++ )
			free(inputString[i]);
		free(inputString);
	   	glutDestroyWindow(myWin);
	   	exit(0);
    	}
    	else {
      		numStrings++;
      		inOne++;
      		if (inOne == MAX_IN_STRINGS) inOne = 0;
	  		gotOne = 0;
      		while (numStrings > 0)	{
		    if (inputString[outOne][0] == '/')	{
			printf(inputString[outOne]);
			fflush(stdout);
		    }
		    else	{
			sscanf(inputString[outOne],"%f %f %f %f\n",
				&params[0],&params[1],&params[2],&params[3]);
			gotOne = 1;
		    }
		    outOne += 1;
		    if (outOne == MAX_IN_STRINGS) outOne = 0;
	   	    numStrings -= 1;
	  	}
	  	if (gotOne)	{
			glutSetWindow(myWin);
			glutPostRedisplay();
	  	}
    	}
   }

  // Free inputString.
  for ( i=0;i<MAX_IN_STRINGS;i++ ) free(inputString[i]);
  free(inputString);

  pthread_cancel(string_thread);
  pthread_join(string_thread, NULL);

//  _endthread();
}

void startPipeThread()
{

//  string_thread = _beginthread(newStringByPipe, 0, NULL);
  if ( pthread_create(&string_thread, NULL, newStringByPipe, NULL) != 0 )  {
    fprintf(stderr, "unable to create input pipe thread ... aborting.\n");
    exit(0);
  }
}

void line(float x, float y, float x2, float y2)
{	
    glBegin(GL_LINES); 
//	  glVertex2f(-x*0.75, y);
//	  glVertex2f(-x2*0.75, y2);
	  glVertex2f(x, y);
	  glVertex2f(x2, y2);
    glEnd();
}

float sine[34],cosine[34];

void zcircle(float x, float y, float r)
{
        int i;
        float xD,yD,xDl,yDl;

        glBegin(GL_LINES);
        xDl = x + r * Y_MAX/X_MAX * 0.9;
        yDl = y + r * 0.9 * 0.0;
        for (i=1;i<=33;i++)     {
          xD = x + r * Y_MAX/X_MAX * 0.9 * cosine[i];
          yD = y + r * sine[i] * 0.9;
          line(xDl,yDl,xD,yD);
          xDl = xD;
          yDl = yD;
        }
        glEnd();
}

void zex(float x, float y, float r)
{
        int i;
	float xr=0.7,yr=1.5;
	xr *= r;
	yr *= r;
        glBegin(GL_LINES);
        line(x-xr,y-yr,x+xr,y+yr);
        line(x-xr,y+yr,x+xr,y-yr);
        glEnd();
}

void zero(float x, float y, float r)
{
        int i;
        float xD,yD,xDl,yDl;        
        glBegin(GL_LINES);
        xDl = x + r * Y_MAX/X_MAX * 0.9;
        yDl = y + r * 0.9;
        for (i=1;i<=33;i++)     {
          xD = x + r * Y_MAX/X_MAX * 0.9 * cosine[i];
          yD = y + r * sine[i] * 0.9;
          line(xDl,yDl,xD,yD);
          xDl = xD;
          yDl = yD;
        }
        glEnd();

//	float xr=0.7,yr=1.5;
//	xr *= r;
//	yr *= r;
//      glBegin(GL_LINES);
        
}

void outtext(float x, float y, char* string)	{
        glColor3f(0.2,0.2,0.2);
	glRasterPos2f( x, y);
	while (*string)	{
		glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18,*string++);
	}
}

void drawPolesNZeroes()	{
    float xcen=0.0,ycen=0.0,rad=0.8;
    float tempx,tempy,temprad;
    glColor3f(0.0,0.0,0.0);
    glRectf(-0.99,-0.99,0.99,0.99);
    glColor3f(1.0,1.0,1.0);
    zcircle(xcen+0.75,ycen,rad);
    temprad = rad * params[1];		// Poles
    tempx = temprad * cos(params[0]/SRATE*TWO_PI);
    tempy = 0.90 * temprad * sin(params[0]/SRATE*TWO_PI);
    outcoeffs[0] = params[1]*2*cos(params[0]/SRATE*TWO_PI);
    outcoeffs[1] = -params[1]*params[1];
    if (temprad > 0.01)	{
	tempx *= 0.25;
	zex(xcen+0.75+tempx,ycen+tempy,0.02);
	zex(xcen+0.75+tempx,ycen-tempy,0.02);
    }
    temprad = rad * params[3];		// Zeroes
    tempx = temprad * cos(params[2]/SRATE*TWO_PI);
    tempy = 0.9 * temprad * sin(params[2]/SRATE*TWO_PI);
    incoeffs[0] = -params[3]*2*sin(params[2]/SRATE*TWO_PI);
    incoeffs[1] = params[3]*params[3];
    if (temprad > 0.01)	{
        tempx *= 0.25;
	zero(xcen+0.75+tempx,ycen+tempy,0.03);
	zero(xcen+0.75+tempx,ycen-tempy,0.03);
    }
    if (params[2]==-1 && params[3]==-1)	{
	zero(xcen+0.95,ycen,0.03);
	zero(xcen+0.55,ycen,0.03);
	incoeffs[0] = 0;
	incoeffs[1] = -1.0;
    }
}

#define MAXLENGTH 1024

void doNDrawWaveAndSpectrum()	{
    float xl=-0.99,yl=0.5;
    float delx = 1.5 / (float) MAXLENGTH;
    float xr=xl+delx,yr=0.5;
    int i;
    float impulse[MAXLENGTH];
    float in=0.0,out=0.0,ins[2]={0.0,0.0},outs[2]={0.0,0.0};
    in = 1.0;
    glBegin(GL_LINES);
    for (i=0;i<MAXLENGTH;i++)	{
	out = in + incoeffs[0]*ins[0] + incoeffs[1]*ins[1];
	out += outcoeffs[0]*outs[0] + outcoeffs[1]*outs[1];
	impulse[i] = out;
	in = 0.0;		// all ya' need is one!!
	ins[1]=ins[0];
	ins[0]=in;
        outs[1]=outs[0];
        outs[0]=out;
	yr = out * 0.1 + 0.5;		// draw something!!
        line(xl,yl,xr,yr);
	yl = yr;
	xr += delx;
	xl += delx;
    }
    glEnd();
}

void fullBox(float color)     {
        glColor3f(color,color,color);
        glRectf(-1.0,-1.0,1.0,1.0);
}

// Some simple GL Hacks to mimic (some) 
// Display PostScript functions from NeXTStep
// Why?  'Cause that's where this all started...
// Why Not Use PS functions in Mac OS?
// Because we want to use GL on all platforms.

void GLHAK_PSsetgray(float graylevel)	{
    glColor3f(graylevel,graylevel,graylevel);
}

#define XNORM 1.94
#define YNORM 1.94
#define XOFFS 0.97
#define YOFFS 0.97

void GLHAK_PSline(float x, float y, float x2, float y2)
{	
    glBegin(GL_LINES); 
	  glVertex2f(XNORM*x - XOFFS, YNORM*y - YOFFS);
	  glVertex2f(XNORM*x2 - XOFFS, YNORM*y2 - YOFFS);
    glEnd();
}

void Redraw(void)	{
    fullBox(0.666);
    drawPolesNZeroes();
    doNDrawWaveAndSpectrum();
}

void IdleStub(void)	{
	;
}

void init(void)
{
    glutPostRedisplay();
}

void display(void)	{
//	glClear( GL_COLOR_BUFFER_BIT ); 
	Redraw();
	glutSwapBuffers();
}

//    glutWMCloseFunc(die);
void die(void)  {
    exit(0);  
}

void SpecialFunc(int key, int x, int y)
{
    if (key==0x1b)  {
	exit(0);
    }
    glutPostRedisplay();
}

void KeyFunc(unsigned char key, int x, int y)
{
    if (key==0x1b)  {
	exit(0);
    }
    glutPostRedisplay();
}

main(int ac, char *av[]    )
{
    int i;
    char titleString[512];
    float scale = 1.0;
    long loc = 0;

    if (ac > 1)	{
	if (av[1][1]=='s') scale = atof(av[2]);
	else {
	    printf("useage: ZViewGL [-s scale]\n");
	    exit(0);
	}
    }

    glutInit(&ac, av);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    strcpy(titleString,"OS X GL ZPlane Viewer");
    glutInitWindowSize(X_MAX*scale,Y_MAX*scale);
    glutInitWindowPosition(730,70);
    myWin = glutCreateWindow(titleString);

    glutDisplayFunc(display);
    glutKeyboardFunc(KeyFunc);
    glutSpecialFunc(SpecialFunc);
    glutIdleFunc(IdleStub);
    glutWMCloseFunc(die);

    glColor4f(0, 0, 0, 0);

    init();

    setbuf(stdin,NULL);
    startPipeThread();

    for (i=0;i<=33;i++)  {
	sine[i] = (float) sin(TWO_PI * (double) i / 32.0);
	cosine[i] = (float) cos(TWO_PI * (double) i / 32.0);
    }

    glutMainLoop();

    return 0;
}