#include <stdio.h>
#include <math.h>
#include <signal.h>
#include <limits.h>
#include <audio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/prctl.h>
#include <sys/schedctl.h>
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include <X11/Xaw/Box.h>
#include <Xm/Xm.h>
#include <Xm/PushB.h>
#include <Xm/Label.h>
#include <Xm/Scale.h>

#define FIFO_SIZE	48000
#define pi 3.1415926535

unsigned int audio_pid;
int audio_mode, sample_param, pitch_param, offset_param;
char *audio_menu[] = { "audio_distrotion", "audio_oscillator", "audio_granular", "audio_effector" };
short buffer[FIFO_SIZE];

void self_kill();
void create_sound();
void sound_off();
void scaler_volume();
void scaler_sample();
void scaler_pitch();
void scaler_offset();
void audio_distrotion();
void audio_oscillator();
void audio_granular();
void audio_effector();

void main(unsigned int argc, char** argv)
{
	Widget toplevel, title, bigbox, sbox[10], pb2[5], pb3[3], volume, sample, pitch, offset;
	XmString xmstr;
	Arg args[10];
	char buf[80];
	int i,n;

/***** Motif Screen Define *****/
	toplevel = XtInitialize( argv[0], "", NULL, 0, &argc, argv );
	bigbox = XtCreateManagedWidget( "", boxWidgetClass, toplevel, NULL, 0 );
	xmstr = XmStringCreateSimple("  (^_^) Audio Test by Yoichi Nagashima (^_^)  ");
	XtSetArg( args[0], XmNlabelString, xmstr );
	title = XtCreateManagedWidget( "", xmLabelWidgetClass, bigbox, args, 1 );
	for(i=0;i<10;i++){
		sbox[i] = XtCreateManagedWidget( "", boxWidgetClass, bigbox, NULL, 0 );
	}
	pb3[0] = XtCreateManagedWidget( "Sound Port OFF", xmPushButtonWidgetClass, sbox[0], NULL, 0 );
	pb3[1] = XtCreateManagedWidget( "Quit to System", xmPushButtonWidgetClass, sbox[0], NULL, 0 );
	pb2[0] = XtCreateManagedWidget( "Mode(1) Distortion", xmPushButtonWidgetClass, sbox[1], NULL, 0 );
	pb2[1] = XtCreateManagedWidget( "Mode(2) Oscillator", xmPushButtonWidgetClass, sbox[1], NULL, 0 );
	pb2[2] = XtCreateManagedWidget( "Mode(3) Granular", xmPushButtonWidgetClass, sbox[1], NULL, 0 );
	pb2[3] = XtCreateManagedWidget( "Mode(4) Effector", xmPushButtonWidgetClass, sbox[1], NULL, 0 );
	n = 0;
	XtSetArg( args[n], XmNminimum, 0 ); n++;
	XtSetArg( args[n], XmNmaximum, 255 ); n++;
	XtSetArg( args[n], XmNscaleHeight, 30 ); n++;
	XtSetArg( args[n], XmNscaleWidth, 250 ); n++;
	XtSetArg( args[n], XmNorientation, XmHORIZONTAL ); n++;
	xmstr = XmStringCreateSimple("Speaker Gain Control");
	XtSetArg( args[n], XmNtitleString, xmstr ); n++;
	XtSetArg( args[n], XmNshowValue, True ); n++;
	volume = XtCreateManagedWidget( "", xmScaleWidgetClass, sbox[2], args, n );
	n = 0;
	XtSetArg( args[n], XmNminimum, 1 ); n++;
	XtSetArg( args[n], XmNmaximum, 99 ); n++;
	XtSetArg( args[n], XmNscaleHeight, 30 ); n++;
	XtSetArg( args[n], XmNscaleWidth, 250 ); n++;
	XtSetArg( args[n], XmNorientation, XmHORIZONTAL ); n++;
	xmstr = XmStringCreateSimple("Gr. Density Control");
	XtSetArg( args[n], XmNtitleString, xmstr ); n++;
	XtSetArg( args[n], XmNshowValue, True ); n++;
	sample = XtCreateManagedWidget( "", xmScaleWidgetClass, sbox[3], args, n );
	n = 0;
	XtSetArg( args[n], XmNminimum, 1 ); n++;
	XtSetArg( args[n], XmNmaximum, 99 ); n++;
	XtSetArg( args[n], XmNscaleHeight, 30 ); n++;
	XtSetArg( args[n], XmNscaleWidth, 250 ); n++;
	XtSetArg( args[n], XmNorientation, XmHORIZONTAL ); n++;
	xmstr = XmStringCreateSimple("Grain Width Control");
	XtSetArg( args[n], XmNtitleString, xmstr ); n++;
	XtSetArg( args[n], XmNshowValue, True ); n++;
	pitch = XtCreateManagedWidget( "", xmScaleWidgetClass, sbox[4], args, n );
	n = 0;
	XtSetArg( args[n], XmNminimum, 1 ); n++;
	XtSetArg( args[n], XmNmaximum, 32 ); n++;
	XtSetArg( args[n], XmNscaleHeight, 30 ); n++;
	XtSetArg( args[n], XmNscaleWidth, 250 ); n++;
	XtSetArg( args[n], XmNorientation, XmHORIZONTAL ); n++;
	xmstr = XmStringCreateSimple("Grain Offset Control");
	XtSetArg( args[n], XmNtitleString, xmstr ); n++;
	XtSetArg( args[n], XmNshowValue, True ); n++;
	offset = XtCreateManagedWidget( "", xmScaleWidgetClass, sbox[5], args, n );

/***** Callback Routine Define *****/
	for(i=0;i<4;i++){
		XtAddCallback( pb2[i], XmNactivateCallback, create_sound, audio_menu[i] );
	}
	XtAddCallback( pb3[0], XmNactivateCallback, sound_off, NULL );
	XtAddCallback( pb3[1], XmNactivateCallback, self_kill, NULL );
	XtAddCallback( volume, XmNvalueChangedCallback, scaler_volume, NULL );
	XtAddCallback( volume, XmNdragCallback, scaler_volume, NULL );
	XtAddCallback( sample, XmNvalueChangedCallback, scaler_sample, NULL );
	XtAddCallback( sample, XmNdragCallback, scaler_sample, NULL );
	XtAddCallback( pitch, XmNvalueChangedCallback, scaler_pitch, NULL );
	XtAddCallback( pitch, XmNdragCallback, scaler_pitch, NULL );
	XtAddCallback( offset, XmNvalueChangedCallback, scaler_offset, NULL );
	XtAddCallback( offset, XmNdragCallback, scaler_offset, NULL );

/***** Start Realize ! *****/
	XtRealizeWidget(toplevel);
	XtMainLoop();
}

void self_kill(Widget w, caddr_t message, caddr_t para)
{
	sound_off();
	printf("\nBye Bye !  (^o^)/\n\n");
	exit(0);
}

void create_sound(Widget w, caddr_t message, caddr_t para)
{
	sound_off();
	if( !strcmp( message, "audio_distrotion" ) ){
		sample_param = 1;
		audio_pid = sproc( audio_distrotion, PR_SALL );
		audio_mode = 1;
	}
	else if( !strcmp( message, "audio_oscillator" ) ){
		sample_param = 1;
		audio_pid = sproc( audio_oscillator, PR_SALL );
		audio_mode = 2;
	}
	else if( !strcmp( message, "audio_granular" ) ){
		sample_param = 1;
		pitch_param = 1;
		audio_pid = sproc( audio_granular, PR_SALL );
		audio_mode = 3;
	}
	else if( !strcmp( message, "audio_effector" ) ){
		sample_param = 16;
		pitch_param = 1;
		offset_param = 1;
		audio_pid = sproc( audio_effector, PR_SALL );
		audio_mode = 4;
	}
	if (audio_pid == -1) exit(-1);
	printf("  Registered Audio PID = %d\n",audio_pid);
}

void sound_off()
{
	long parameter_buffer[4];
	if(audio_pid != 0){
		parameter_buffer[0] = AL_LEFT_SPEAKER_GAIN;
		parameter_buffer[2] = AL_RIGHT_SPEAKER_GAIN;
		ALgetparams( AL_DEFAULT_DEVICE, parameter_buffer, 4 );
		parameter_buffer[1] = 50;
		parameter_buffer[3] = 50;
		ALsetparams( AL_DEFAULT_DEVICE, parameter_buffer, 4 );
		kill(audio_pid, SIGKILL);
		audio_pid = 0; audio_mode = 0;
		printf("  Killed : Audio PID = %d\n",audio_pid);
	}
}

void scaler_volume(Widget w, caddr_t message, caddr_t para)
{
	long parameter_buffer[4];
	XmScaleCallbackStruct  *callback = (XmScaleCallbackStruct *) para;
	parameter_buffer[0] = AL_LEFT_SPEAKER_GAIN;
	parameter_buffer[2] = AL_RIGHT_SPEAKER_GAIN;
	ALgetparams( AL_DEFAULT_DEVICE, parameter_buffer, 4 );
	parameter_buffer[1] = callback->value;
	parameter_buffer[3] = callback->value;
	ALsetparams( AL_DEFAULT_DEVICE, parameter_buffer, 4 );
}

void scaler_sample(Widget w, caddr_t message, caddr_t para)
{
	XmScaleCallbackStruct  *callback = (XmScaleCallbackStruct *) para;
	sample_param = callback->value;
}

void scaler_pitch(Widget w, caddr_t message, caddr_t para)
{
	int i, width;
	XmScaleCallbackStruct  *callback = (XmScaleCallbackStruct *) para;
	pitch_param = callback->value;
	if( audio_mode == 3){
		width = 64 + 4 * pitch_param;
		for(i=0;i<width;i++) buffer[i] = (short)( 800.0 * ( 1.0 + sin(2.0*pi*(double)i/(double)width + 2.0*pi*3.0/4.0)));
		for(i=width;i<FIFO_SIZE;i++) buffer[i] = 0;
	}
}

void scaler_offset(Widget w, caddr_t message, caddr_t para)
{
	XmScaleCallbackStruct  *callback = (XmScaleCallbackStruct *) para;
	offset_param = callback->value;
}

void audio_distrotion()
{
	ALconfig	config;
	ALport		input_port, output_port;
	short		buff[1024];
	int		i;
	config = ALnewconfig();
	ALsetqueuesize( config, 1024 );
	input_port = ALopenport( "input", "r", config );
	output_port = ALopenport( "output", "w", config );
	if ( input_port == NULL || output_port == NULL ) exit(-1);
	schedctl(NDPRI, 0, NDPNORMMAX);
	while (1)
	{
		if( ALgetfilled(input_port) > sample_param ){
			ALreadsamps( input_port, buff, sample_param );
		}
		if( ALgetfillable(output_port) > sample_param ){
			for(i=0;i<sample_param;i++){
				ALwritesamps( output_port, buff, 1 );
			}
		}
	}
}

void audio_oscillator()
{
	ALconfig	config;
	ALport		output_port;
	short		buff[256];
	unsigned int	read_pointer=0;
	int		i;
	config = ALnewconfig();
	ALsetqueuesize( config, FIFO_SIZE );
	output_port = ALopenport( "output", "w", config );
	if ( output_port == NULL ) exit(-1);
	for(i=0;i<256;i++) buffer[i] = (short)( 15000.0 * sin( 2.0 * pi * (double)i / 256.0 ));
	for(i=256;i<FIFO_SIZE;i++) buffer[i] = 0;
	while (1)
	{
		if( ALgetfillable(output_port) > 256 ){
			for(i=0;i<256;i++){
				buff[i] = buffer[read_pointer++];
				if( read_pointer > sample_param * 256 ) read_pointer=0;
			}
			ALwritesamps( output_port, buff, 256 );
		}
	}
}

void audio_granular()
{
	ALconfig	config;
	ALport		output_port;
	short		buff[256];
	unsigned int	read_pointer[20];
	int		i, j;
	config = ALnewconfig();
	ALsetqueuesize( config, FIFO_SIZE );
	output_port = ALopenport( "output", "w", config );
	if ( output_port == NULL ) exit(-1);
	for(i=0;i<20;i++) read_pointer[i] = 0;
	for(i=0;i<128;i++) buffer[i] = (short)( 800.0 * ( 1.0 + sin( 2.0 * pi * (double)i / 128.0 + 2.0 * pi * 3.0 / 4.0 )));
	for(i=128;i<FIFO_SIZE;i++) buffer[i] = 0;
	while (1)
	{
		if( ALgetfillable(output_port) > 256 ){
			for(i=0;i<256;i++){
				buff[i] = 0;
				for(j=0;j<20;j++){
					buff[i] = buff[i] + buffer[read_pointer[j]++];
					if( read_pointer[j] > ( sample_param + 10 ) * 10 * (j+5) ) read_pointer[j] = 0;
				}
			}
			ALwritesamps( output_port, buff, 256 );
		}
	}
}

void audio_effector()
{
	ALconfig	config;
	ALport		input_port, output_port;
	short		buff[1024];
	float		shift, weight[1024];
	unsigned int	read_pointer[32];
	int		i, j;
	config = ALnewconfig();
	ALsetqueuesize( config, 4096 );
	input_port = ALopenport( "input", "r", config );
	output_port = ALopenport( "output", "w", config );
	if ( input_port == NULL || output_port == NULL ) exit(-1);
	for(i=0;i<32;i++) read_pointer[i] = 0;
	for(i=0;i<1024;i++) weight[i] = ( 1.0 + sin( 2.0 * pi * (float)i / 1024.0 + 2.0 * pi * 3.0 / 4.0 )) / 2.0;
	for(i=0;i<FIFO_SIZE;i++) buffer[i] = 0;
	schedctl(NDPRI, 0, NDPNORMMAX);
	while (1)
	{
		if( ALgetfilled(input_port) > 1024 ){
			ALreadsamps( input_port, buff, 1024 );
			shift = 1024.0 - ( (float)pitch_param - 1.0 ) * 9.8;
			for(i=0;i<(int)shift;i++){
				j = (int)( (float)i * 1024.0 / shift );
				buffer[i] = (short)( (float)buff[j] * weight[j] / 32.0 );
			}
			for(i=(int)shift;i<1024;i++) buffer[i] = 0;
		}
		if( ALgetfillable(output_port) > 256 ){
			for(i=0;i<256;i++){
				buff[i] = 0;
				for(j=0;j<32;j++){
					buff[i] = buff[i] + buffer[read_pointer[j]++];
					if( read_pointer[j] > 1001 + 32 * sample_param + j * offset_param ) read_pointer[j] = 0;
				}
			}
			ALwritesamps( output_port, buff, 256 );
		}
	}
}