/**************************************************************************
 *                                                                        *
 *               Copyright (C) 1995, Silicon Graphics, Inc.               *
 *                                                                        *
 *  These coded instructions, statements, and computer programs  contain  *
 *  unpublished  proprietary  information of Silicon Graphics, Inc., and  *
 *  are protected by Federal copyright  law.  They  may not be disclosed  *
 *  to  third  parties  or copied or duplicated in any form, in whole or  *
 *  in part, without the prior written consent of Silicon Graphics, Inc.  *
 *                                                                        *
 *************************************************************************/

/*---------------------------------------------------------------------*
        Copyright (C) 1998 Nintendo. (Originated by SGI)
        
        $RCSfile: main.c,v $
        $Revision: 1.1.1.1 $
        $Date: 2002/05/02 03:27:26 $
 *---------------------------------------------------------------------*/

/*
 * File:  main.c
 *
 *  Compiler Flags:
 *  o  _DEBUG - compile with rmon thread
 *
 *  The stress application is designed to touch as many different
 *  parts of the software interface as possible.  These include
 *
 *    Graphics      - use many different texture types, shading, lighting,
 *            transparency, copy, fill, etc.
 *
 *    Memory Mgmt.  - use static and dynamic segments, show some simple
 *            animation capability.
 *
 *    Audio     - play a test MIDI sequence
 *
 *    IO Manager    - simultaneous DMA activity from ROM to DRAM for audio
 *          and graphics streams.
 *
 *    VI Manager    - double buffer display, maybe a few video modes
 *
 *    Overloads     - demonstrate techniques for handling graphics overruns,
 *          cpu overruns, task yielding, etc.
 *
 *    Task Swapping     - demonstrate microcode task swapping
 *
 *    Timers        - demonstrate timer functionality
 *
 *    Sprite Library    - demonstrate some simple sprite operations
 *
 *    Controllers   - use serial controller gadgets to toggle some
 *            state within the application.
 *
 *    Because this application is meant to stress the system, it is purposefully
 *    wasteful of system bandwidth in some cases.
 *    
 */

#include <ultra64.h>
#include <ultralog.h>
#include <sched.h>
#include <assert.h>
#include <ramrom.h>

#include "stress.h"
#include "texture.h"
#include "vect.h"
#include "flight_path.h"
#include "audio.h"

#define NUM_PI_MSGS     		8
#define SP_UCODE_SIZE           4096
#define SP_UCODE_DATA_SIZE      2048

#define SCHED_CONTROLLER_MSG    (OS_SC_LAST_MSG+1)

/*
 *  Mode definitions
 */
typedef enum {
	D_MOUNTAINS = 1,
	D_POOL = 2,
	D_ORB = 4,
	D_CLOCK = 8,
	D_ALTIMETER = 16
} DisplayEnable;

typedef enum {
	M_BFCULL = 1,
	M_RGBDITHER = 2,
	M_TEXBILERP = 4,
	M_TEXPERSP = 8
} ModeEnable;

typedef enum {
	STILL, ORBIT, FLY
} FlyMode;

static DisplayEnable   DisplayEn = D_ORB | D_POOL | D_MOUNTAINS;
static ModeEnable      ModeEn = M_BFCULL | M_RGBDITHER | M_TEXBILERP | 
								M_TEXPERSP;
static FlyMode         flymode = ORBIT;
static u32      	   CurView = 0;

/*
 *  Message logging stuff
 */
#define LOG_SCHEDULE_GFX_TASK	101
#define LOG_RDP_DONE		    102
#define LOG_RETRACE		    	103
#define LOG_INTR		    	104
#define LOG_SWAPREQUEST		    105

#define LOG_LEN 				0x2000

OSLog           logger;
OSLog          *log = &logger;
u32             logData[LOG_LEN];


/*
 * Symbol genererated by "makerom" to indicate the end of the code segment
 * in virtual (and physical) memory
 */
extern char     _codeSegmentEnd[];
extern char     _cfbSegmentEnd[];

/*
 * Symbols generated by "makerom" to tell us where the static segment is
 * in ROM.
 */
extern char     _staticSegmentRomStart[],
                _staticSegmentRomEnd[];
extern char     _textureSegmentRomStart[],
                _textureSegmentRomEnd[];

char           *staticSegment;
char           *textureSegment;

/*
 * Stacks for the threads as well as message queues for synchronization
 */
u32		token0 = 0xdead0000;
u64             bootStack[BOOT_STACKSIZE / sizeof(u64)];
u32		token1 = 0xdead0001;
u64             stressloopThreadStack[STRESS_STACKSIZE / sizeof(u64)];
u32		token2 = 0xdead0002;
u64             mainThreadStack[MAIN_STACKSIZE / sizeof(u64)];
u32		token3 = 0xdead0003;
u64             audioStack[AUDIO_STACKSIZE / sizeof(u64)];
u32		token4 = 0xdead0004;

u64             rmonStack[RMON_STACKSIZE / sizeof(u64)];
u32		token5 = 0xdead0005;
u64             scheduleStack[OS_SC_STACKSIZE / sizeof(u64)];
u32		token6 = 0xdead0006;
OSSched         sc;
u32		token7 = 0xdead0007;

static OSThread stressThread;
static OSThread mainThread;
static OSThread rmonThread;

static OSMesg   	PiMessages[NUM_PI_MSGS];
static 	OSMesgQueue PiMessageQ;

OSMesgQueue     dmaMessageQ,
                rdpMessageQ,
                retraceMessageQ,
                rspMessageQ;
OSMesg          dmaMessageBuf,
                taskMessageBuf,
                retraceMessageBuf,
                rspMessageBuf;
OSIoMesg        dmaIOMessageBuf;

OSMesgQueue     gfxFrameMsgQ;
OSMesg          gfxFrameMsgBuf[MAX_MESGS];

/*
 * function prototypes for private functions in this file
 */
static void     main(void *);
static void     parse_args(char *argstring);
static void     stressloop(void *);
static void     initAudio(ALHeap * hp);
static void     create_gfx_tasks(GFXInfo *);
static void     romCopy(char *src, char *dest, int len);
static int      initControllers(void);
static void 	BuildGraphicsTask(OSTask *, Gfx *, u32);
static void		set_user_modes(void);
static void		set_display(Dynamic *);

/*
 *  External functions
 */
void			make_waves(Dynamic *);
void			getflytransform( float mat[4][4] );
void 			get_fp_position( float p,
                   float *vx, float *vy, float *vz,
                   float *ax, float *ay, float *az,
           		   float *ux, float *uy, float *uz);
void			clock_init(void);
void			do_clock(Gfx **);

/*
 *  Controller Data
 */
static OSContStatus statusdata[MAXCONTROLLERS];
static OSContPad controllerdata[MAXCONTROLLERS];

/*
 * XXX header!! public - shared by rmon and users 
 */
extern OSMesgQueue rmonCalloutMQ;

extern void     rmonMain(void *);

/*
 *  Matrix stack for RSP
 */
extern u64      dram_stack[];

/*
 *  rdp command buffer
 */
extern u64      rdp_output[];
extern u64      rdp_output_len;

/*
 *   must be in BSS, not on the stack for this to work:
 */

/*
 *   Double-buffered dynamic segments
 */
static GFXInfo	gInfo[2];
Gfx            *glistp;

/*
 *   global variables for arguments, to control test cases
 */
u32      		Logging;
static u32      Debugflag;
static u32      Verbose;
static u32      Silent;
static u32      Trap;
static u32      GbiDump;

/*
 *  Scheduler stuff
 */
static int      framecount;
static OSMesgQueue *schedqueue;
static GFXMsg   controllermsg;

/*
 *  Controller data
 */
static s8       velocity;
static s8       lastx;
static s8       lasty;
static u16      lastbutton;


/*
 *  Position, Attitude
 */
float           time = 0.0;
float           timeinc = 7.0;
float           Vpx,
                Vpy,
                Vpz;
float           Atx,
                Aty,
                Atz;
float           Upx,
                Upy,
                Upz;
float           ViewAlt[5] = {100.0, 1300.0, 500.0, 500.0, 500.0};
float           ViewXpos[5] = {300.0, 300.0, 200.0, 0.0, -500.0};
float           ViewZpos[5] = {650.0, 2350.0, 800.0, 5000.0, -500.0};

/*
 *  Audio Stuff
 */

ALSeqPlayer    *seqp;
static char    *seqPtr;
static int      seqLen;
static ALSeq   *seq;
static ALSeqMarker seqStart;
static ALSeqMarker seqEnd;
ALHeap          hp;
u8            audioHeap[AUDIO_HEAP_SIZE];



/*
 *  Boot
 */
OSPiHandle	*handler;

boot(char *arg)
{
	int             i;
	char           *ap;
	u32            *argp;
	u32             argbuf[16];

	osInitialize();

	handler = osCartRomInit();

	argp = (u32 *) RAMROM_APP_WRITE_ADDR;
	for (i = 0; i < sizeof(argbuf) / 4; i++, arg++) {
		osEPiReadIo(handler, (u32) argp, &argbuf[i]);	/*
												 * assume no DMA 
												 */
	}

	/*
	 * parse the options 
	 */
	parse_args((char *) argbuf);

	osCreateThread(&mainThread, 1, main, (void *) arg,
				   mainThreadStack + MAIN_STACKSIZE / sizeof(u64), MAIN_PRIORITY);
	osStartThread(&mainThread);

	/*
	 * Never Reached - feel free to use bootStack 
	 */
}

/*
 *      M a i n
 */
void
main(void *arg)
{
	/*
	 * Initialize video
	 */
	osCreateViManager(OS_PRIORITY_VIMGR);
	/* osViSetMode(&osViModeTable[OS_VI_NTSC_LAN1]); */

	/*
	 * Start PI Mgr for access to cartridge
	 */
	osCreatePiManager((OSPri) OS_PRIORITY_PIMGR, &PiMessageQ, PiMessages, 
		NUM_PI_MSGS);

	/*
	 * Start RMON for debugging (make sure to start PI Mgr first
	 */
#ifdef _DEBUG
	osCreateThread(&rmonThread, 4, rmonMain, (void *) 0,
				   rmonStack + RMON_STACKSIZE / sizeof(u64), OS_PRIORITY_RMON);
	osStartThread(&rmonThread);
#endif 

	/*
	 * Create stress thread
	 */
	osCreateThread(&stressThread, 6, stressloop, (void *) 0,
				   stressloopThreadStack + STRESS_STACKSIZE / sizeof(u64), 
				   STRESS_PRIORITY);

	if (!Debugflag)
		osStartThread(&stressThread);

	/*
	 * Become the idle thread
	 */
	osSetThreadPri(0, 0);
	for (;;) ;
}

/*
 *  Main Stress Loop
 */
void
stressloop(void *arg)
{
	char           *i;
	unsigned int    sum;

	int             displaybuffer = 0;
	int             drawbuffer = 0;
	int             bufCnt = 0;
	GFXMsg         *msg;
	OSScClient      client;
	GFXInfo        *gfxp;
	int             controller;
	int             controllervalid = 1;
	OSContPad      *pad;
	s8              roll,
	                pitch;
	if (DisplayEn & D_CLOCK)
		clock_init();

	if (Logging)
		osCreateLog(log, logData, LOG_LEN);

	/*
	 * Initialize the RCP task scheduler 
	 */
	osCreateMesgQueue(&dmaMessageQ, &dmaMessageBuf, MAX_MESGS);
	osCreateScheduler(&sc, 
				(void *) (scheduleStack + OS_SC_STACKSIZE / sizeof(u64)),
				SCHEDULER_PRIORITY, OS_VI_NTSC_LAN1, NUM_FIELDS);

	/*
	 * DMA models and textures
	 */
	staticSegment = _cfbSegmentEnd;
	romCopy(_staticSegmentRomStart, staticSegment,
			_staticSegmentRomEnd - _staticSegmentRomStart);


	textureSegment = (_staticSegmentRomEnd - _staticSegmentRomStart) +
	  _cfbSegmentEnd;


	romCopy(_textureSegmentRomStart, textureSegment,
			_textureSegmentRomEnd - _textureSegmentRomStart);

	osViSetSpecialFeatures(OS_VI_DIVOT_OFF | OS_VI_GAMMA_ON);

	if (ModeEn & M_RGBDITHER) {
		osViSetSpecialFeatures(OS_VI_DITHER_FILTER_ON);
	} else {
		osViSetSpecialFeatures(OS_VI_DITHER_FILTER_OFF);
	}

	/*
	 *  Initialize flying controls
	 */
	/* fly_init(); */

	if (!Silent) {
		initAudio(&hp);
		alSeqpPlay(seqp);
	}

	gInfo[0].msg.gen.type = OS_SC_DONE_MSG;
	gInfo[0].cfb = cfb_16_a;
	gInfo[1].msg.gen.type = OS_SC_DONE_MSG;
	gInfo[1].cfb = cfb_16_b;
	controllermsg.gen.type = SCHED_CONTROLLER_MSG;

	osCreateMesgQueue(&gfxFrameMsgQ, gfxFrameMsgBuf, MAX_MESGS);

	osScAddClient(&sc, &client, &gfxFrameMsgQ);

	if ((controller = initControllers()) < 0)
		controllervalid = 0;
	else
		controllervalid = 1;

	osSetEventMesg(OS_EVENT_SI, &gfxFrameMsgQ, (OSMesg) & controllermsg);


	/*
	 * Main stress loop
	 */
	while (1) {
		(void) osRecvMesg(&gfxFrameMsgQ, (OSMesg *) & msg, OS_MESG_BLOCK);

		switch (msg->gen.type) {
				/*
				 * Received every retrace
				 * Create a new gfx task unless we are overrunning
				 */
			case (OS_SC_RETRACE_MSG):
				if (Logging)
					osLogEvent(log, LOG_RETRACE, 1, bufCnt);

				if (bufCnt < 2) {
					create_gfx_tasks(&gInfo[drawbuffer]);
					bufCnt++;
					drawbuffer ^= 1;
				}
				/*
				 * request latest controller information 
				 */
				if (controllervalid) {
					osContStartReadData(&gfxFrameMsgQ);
					controllervalid = 0;
				}

				break;

			case (OS_SC_DONE_MSG):
				gfxp = &gInfo[displaybuffer];

				if (Logging)
					osLogEvent(log, LOG_RDP_DONE, 3, gfxp->cfb, framecount);

				displaybuffer ^= 1;
				framecount++;
				bufCnt--;
				if (framecount >= 3000) {
					framecount = 0;
					if(Logging)
						osFlushLog(log);
				}
				break;

			case SCHED_CONTROLLER_MSG:

				osContGetReadData(controllerdata);
				controllervalid = 1;
				pad = &controllerdata[controller];

				if (pad->button & CONT_START && !(lastbutton & CONT_START)) {
					if (flymode == FLY)
						flymode = STILL;
					else
						flymode++;
				}
				if ((pad->button & CONT_R) && !(lastbutton & CONT_R))
					timeinc += .3;

				if ((pad->button & CONT_L) && !(lastbutton & CONT_L))
					timeinc -= .3;

				lastx = pad->stick_x;
				lasty = pad->stick_y;
				lastbutton = pad->button;
				break;

            case (OS_SC_PRE_NMI_MSG):
            	bufCnt += 2;
                break;
       

			default:
				PRINTF("gameproc loop unknown intr 0x%x\n", msg->gen.type);
				break;
		}
	}
	alSeqpStop(seqp);
}

/*
 *  Draw loop
 */
static void
create_gfx_tasks(GFXInfo * info)
{
	OSScTask       *t;
	u16             pnorm;
	Dynamic        *dynamicp;
	float           eye_mat[4][4];
	

	/*
	 * pointers to build the display list.
	 */
	dynamicp = &info->dp;
	glistp = dynamicp->glist;

	/*
	 *  Animate texture maps
	 */
	make_waves(dynamicp);

	/*
	 *  Get matrix for eye point position
	 */
/*
	getflytransform(eye_mat);
*/
	myidentity(eye_mat);
	guMtxF2L(eye_mat, &(dynamicp->eye));
	/*
	 *  Calculate Matrices
	 */
	guPerspective(&dynamicp->projection, &pnorm,
				  33, 320.0 / 240.0, 100, 10000, 1.0);

	switch (flymode) {

		case STILL:
			guLookAt(&dynamicp->viewing,
					 ViewXpos[CurView], ViewAlt[CurView], ViewZpos[CurView],
					 125, 0, 110,
					 0, 1, 0);

			if(DisplayEn & D_ORB) {
				/*
			 	* look at lighted sphere, matrix is not used 
			 	*/
				guLookAtHilite(&dynamicp->dummy_mtx,
						   &(dynamicp->lookat[0]),
						   &(dynamicp->hilite[0]),
						   ViewXpos[CurView], 
						   ViewAlt[CurView], 
						   ViewZpos[CurView],
						   0, 100, 0,
						   0, 1, 0,
						   32.0, 64.0, 32.0,	/*
												 * lt0 direction 
												 */
						   1.0, 1.0, 1.0,	/*
											 * not used 
											 */
						   32, 32);		/*
										 * texture width 
										 */
			}
			break;

		case ORBIT:

			if (time > 1000 * 60 * 2.1)
				time = 0.0;

			Atx = sinf(time / 1000 * 2 * M_PI) * 370;
			Aty = cosf(time / 500 * 2 * M_PI) * 125 + 175;
			Atz = cosf(time / 1000 * 2 * M_PI) * 850;
			time += timeinc;

			guLookAt(&dynamicp->viewing,
					 Atx, Aty, Atz,
					 125, 50, 110,
					 0, 1, 0);

			/*
			 * look at lighted sphere, matrix is not used 
			 */
			guLookAtHilite(&dynamicp->dummy_mtx,
						   &(dynamicp->lookat[0]),
						   &(dynamicp->hilite[0]),
						   Atx, Aty, Atz,
						   0, 100, 0,
						   0, 1, 0,
						   32.0, 64.0, 32.0,	/*
												 * lt0 direction 
												 */
						   1.0, 1.0, 1.0,	/*
											 * not used 
											 */
						   32, 32);		/*
										 * texture width 
										 */

			break;

		case FLY:

			if (time > 31.0)
				time = 0.0;

			get_fp_position(time,
							&Vpx, &Vpy, &Vpz,
							&Atx, &Aty, &Atz,
							&Upx, &Upy, &Upz);

			guLookAt(&dynamicp->viewing,
					 Vpx, Vpy, Vpz,
					 Atx, Aty, Atz,
					 Upx, Upy, Upz);

			/*
			 * look at lighted sphere, matrix is not used 
			 */
			guLookAtHilite(&dynamicp->dummy_mtx,
						   &(dynamicp->lookat[0]),
						   &(dynamicp->hilite[0]),
						   Vpx, Vpy, Vpz,
						   Atx, Aty, Atz,
						   Upx, Upy, Upz,
						   32.0, 64.0, 32.0,	/*
												 * lt0 direction 
												 */
						   1.0, 1.0, 1.0,	/*
											 * not used 
											 */
						   32, 32);		/*
										 * texture width 
										 */

			time += (timeinc / 10.0);
			break;
	}
	/*
	 * Set up segment registers
	 */
	gSPSegment(glistp++, DYNAMIC_SEGMENT, 
				(void *) osVirtualToPhysical(dynamicp));
	gSPSegment(glistp++, PHYSICAL_SEGMENT, 0);
	gSPSegment(glistp++, STATIC_SEGMENT,
			   (void *) osVirtualToPhysical(staticSegment));
	gSPSegment(glistp++, TEXTURE_SEGMENT,
			   (void *) osVirtualToPhysical(textureSegment));
	gSPSegment(glistp++, CFB_SEGMENT,
			   (void *) osVirtualToPhysical(info->cfb));

	/*
	 * set pipeline mode, send BOWTIEVAL, set clipping frustrum ratio
	 */
/*
	gDPPipelineMode(glistp++, G_PM_1PRIMITIVE);
	gSPTexture(glistp++, 0, 0, 0, 0, G_OFF);
	gSPClipRatio(glistp++, FRUSTRATIO_2);
*/

	/*
	 *  Scale factor for W, keeps W at about 1.0 through divide
	 */
	gSPPerspNormalize(glistp++, pnorm);

	/*
	 *  Get static gfx commands
	 */
	gSPDisplayList(glistp++, &(gfxinit_dl[0]));

	/*
	 *  Display pieces of the scene
	 */
	set_user_modes();
	set_display(dynamicp);

	/*
	 *  required
	 */
	gDPFullSync(glistp++);
	gSPEndDisplayList(glistp++);

	assert((glistp - dynamicp->glist) < GFXDLSIZE);

	/*
	 *  Only write back dynamic structure, since this is only data
	 *  in display list that changed.
	 */
	osWritebackDCache(&info->dp, (int)glistp - (int)&info->dp);

	/*
	 * build graphics task 
	 */
	t = &info->task;
	BuildGraphicsTask(&t->list, dynamicp->glist,
			(int) (glistp - dynamicp->glist) * sizeof(Gfx));


	/*
	 *  Build scheduler task
	 */
	t->next = 0;
	t->flags = OS_SC_NEEDS_RSP | OS_SC_NEEDS_RDP | OS_SC_LAST_TASK |
			OS_SC_SWAPBUFFER;
	t->msgQ = &gfxFrameMsgQ;
	t->msg = (OSMesg) & info->msg;
	t->framebuffer = (void *) info->cfb;

	osSendMesg(osScGetCmdQ(&sc), (OSMesg) t, OS_MESG_BLOCK);
}

/*
 *  Interpret Command Line options
 */
static void 
parse_args(char *argstring)
{
	int             argc = 1,
	                i;
	char           *arglist[32],
	              **argv = arglist;		/*
										 * max 32 args 
										 */
	char           *c,
	               *ptr;

	if (argstring == NULL || argstring[0] == '\0')
		return;

	/*
	 * re-organize argstring to be like main(argv,argc) 
	 */
	ptr = argstring;
	while (*ptr != '\0') {
		while (*ptr != '\0' && (*ptr == ' ')) {
			*ptr = '\0';
			ptr++;
		}
		if (*ptr != '\0')
			arglist[argc++] = ptr;
		while (*ptr != '\0' && (*ptr != ' ')) {
			ptr++;
		}
	}

	/*
	 * process the arguments: 
	 */
	while ((argc > 1) && (argv[1][0] == '-')) {
		switch (argv[1][1]) {

			case 'd':
				Debugflag = 1;
				break;

			case 'v':
				Verbose = 1;
				break;

			case 's':
				Silent = 1;
				break;

			case 'l':
				Logging = 1;
				break;

			case 'g':
				GbiDump = 1;
				break;

			case 't':
				Trap = 1;
				break;

			default:
				break;
		}
		argc--;
		argv++;
	}
}


/*
 *  Copy data from ROM to DRAM
 */
void 
romCopy(char *src, char *dest, int len)
{
	OSIoMesg        dmaIoMesgBuf;
	OSMesg          dummyMesg;

	osWritebackDCacheAll();

	dmaIoMesgBuf.hdr.pri      = OS_MESG_PRI_NORMAL;
	dmaIoMesgBuf.hdr.retQueue = &dmaMessageQ;
	dmaIoMesgBuf.dramAddr     = dest;
	dmaIoMesgBuf.devAddr      = (u32)src;
	dmaIoMesgBuf.size         = len;

	osEPiStartDma(handler, &dmaIoMesgBuf, OS_READ);
	(void) osRecvMesg(&dmaMessageQ, &dummyMesg, OS_MESG_BLOCK);
}

/*
 *  Initialize Audio
 */
static void 
initAudio(ALHeap * hp)
{
	ALBankFile     *bankPtr;
	int             bankLen;
	ALSynConfig     c;
	ALSeqpConfig    seqc;

	alHeapInit(hp, audioHeap, sizeof(audioHeap));

	/*
	 * Load the bank file from ROM
	 */
	bankLen = _bankSegmentRomEnd - _bankSegmentRomStart;
	bankPtr = alHeapAlloc(hp, 1, bankLen);
	romCopy(_bankSegmentRomStart, (char *) bankPtr, bankLen);

	alBnkfNew(bankPtr, _tableSegmentRomStart);

	/*
	 * Load the sequence file from ROM
	 */
	seqLen = _seqSegmentRomEnd - _seqSegmentRomStart;
	seqPtr = alHeapAlloc(hp, 1, seqLen);
	romCopy(_seqSegmentRomStart, seqPtr, seqLen);

	/*
	 * Create the Audio Manager
	 */
	c.maxVVoices = MAX_VOICES;
	c.maxPVoices = MAX_VOICES;
	c.maxUpdates = MAX_UPDATES;
	c.dmaproc = 0;				/*
								 * audio mgr will fill this in 
								 */
	c.fxType = AL_FX_SMALLROOM;
	c.outputRate = osAiSetFrequency(32000);
	c.heap = hp;

	amCreateAudioMgr(&c, AUDIO_PRIORITY);

	/*
	 * Create the sequence and the sequence player
	 */
	seqc.maxVoices = MAX_VOICES;
	seqc.maxEvents = MAX_EVENTS;
	seqc.maxChannels = 16;
	seqc.heap = hp;
	seqc.initOsc = 0;
	seqc.updateOsc = 0;
	seqc.stopOsc = 0;
#ifdef _DEBUG
	seqc.debugFlags =  NO_SOUND_ERR_MASK;
#endif
	seqp = alHeapAlloc(hp, 1, sizeof(ALSeqPlayer));
	alSeqpNew(seqp, &seqc);

	seq = alHeapAlloc(hp, 1, sizeof(ALSeq));
	alSeqNew(seq, seqPtr, seqLen);
	alSeqNewMarker(seq, &seqStart, 0);
    alSeqNewMarker(seq, &seqEnd, -1);

    alSeqpLoop(seqp, &seqStart, &seqEnd, -1);
	alSeqpSetSeq(seqp, seq);
	alSeqpSetBank(seqp, bankPtr->bankArray[0]);
}



/*
 *
 * Return the lowest number controller connected to system
 */
static int 
initControllers()
{
	OSMesgQueue     tempMsgQ;
	OSMesg          tempMsg;
	int             i;
	u8              pattern;

	osCreateMesgQueue(&tempMsgQ, &tempMsg, 1);
	osSetEventMesg(OS_EVENT_SI, &tempMsgQ, (OSMesg) 1);

	osContInit(&tempMsgQ, &pattern, &statusdata[0]);

	for (i = 0; i < MAXCONTROLLERS; i++) {
		if ((pattern & (1 << i)) &&
			!(statusdata[i].errno & CONT_NO_RESPONSE_ERROR))
			return i;
	}
	return -1;
}


/*
 *  Build 3-D Graphics Task List
 */
static void
BuildGraphicsTask(OSTask * tlistp, Gfx * data_ptr, u32 data_size)
{
	tlistp->t.type = M_GFXTASK;
	tlistp->t.flags = OS_TASK_DP_WAIT;
	tlistp->t.ucode_boot = (u64 *) rspbootTextStart;
	tlistp->t.ucode_boot_size = ((int) rspbootTextEnd -
								 (int) rspbootTextStart);

	/*
	 * SP output over XBUS to DP: 
	 */
	tlistp->t.ucode = (u64 *) gspFast3DTextStart;
	tlistp->t.ucode_data = (u64 *) gspFast3DDataStart;

	if (Trap) {
		tlistp->t.ucode = (u64 *) gspFast3D_dramTextStart;
		tlistp->t.ucode_data = (u64 *) gspFast3D_dramDataStart;
	}
	tlistp->t.ucode_size = SP_UCODE_SIZE;
	tlistp->t.ucode_data_size = SP_UCODE_DATA_SIZE;
	tlistp->t.dram_stack = (u64 *) &(dram_stack[0]);
	tlistp->t.dram_stack_size = SP_DRAM_STACK_SIZE8;

	tlistp->t.output_buff = (u64 *) 0x0;
	tlistp->t.output_buff_size = (u64 *) 0x0;

	if (Trap) {
		tlistp->t.output_buff = (u64 *) rdp_output;
		tlistp->t.output_buff_size = (u64 *) &(rdp_output_len);
	}
	tlistp->t.yield_data_ptr = (u64 *) gfxYieldBuf;
	tlistp->t.yield_data_size = OS_YIELD_DATA_SIZE;

	/*
	 * initial display list: 
	 */
	tlistp->t.data_ptr = (u64 *) data_ptr;
	tlistp->t.data_size = data_size;

    if(GbiDump) {
		guParseGbiDL(tlistp->t.data_ptr, tlistp->t.data_size, 0);
		osExit();
	}

}

/*
 *  Build Line Task List
 */
#ifdef LATER
static void
BuildLineTask(OSTask * tlistp, int draw_buffer)
{
	tlistp->t.type = M_GFXTASK;
	tlistp->t.flags =			/*
								 * OS_TASK_DP_WAIT 
								 */ 0x0;
	tlistp->t.ucode_boot = (unsigned long long *) rspbootTextStart;
	tlistp->t.ucode_boot_size = ((int) rspbootTextEnd -
								 (int) rspbootTextStart);

	tlistp->t.ucode = (unsigned long long *) gspLine3DTextStart;
	tlistp->t.ucode_data = (unsigned long long *) gspLine3DDataStart;

	if (Trap) {
		tlistp->t.ucode = (unsigned long long *) gspLine3D_dramTextStart;
		tlistp->t.ucode_data = (unsigned long long *) gspLine3D_dramDataStart;
	}
	tlistp->t.ucode_size = 4096;
	tlistp->t.ucode_data_size = 2048;
	tlistp->t.dram_stack = (unsigned long long *) &(dram_stack[0]);
	tlistp->t.dram_stack_size = SP_DRAM_STACK_SIZE8;

	tlistp->t.output_buff = (unsigned long long *) 0x0;
	tlistp->t.output_buff_size = (unsigned long long *) 0x0;

	if (Trap) {
		tlistp->t.output_buff = (unsigned long long *) rdp_output;
		tlistp->t.output_buff_size = (unsigned long long *) &(rdp_output_len);
	}
	/*
	 * initial display list: 
	 */
	tlistp->t.data_ptr = (unsigned long long *)
	  dynamicBuffer[draw_buffer].lnlist;
	tlistp->t.data_size = ((int) (lnlistp - dynamicBuffer[draw_buffer].lnlist) *
						   sizeof(Gfx));
}
#endif /* LATER */


/*
 *  Set User-Defined Attributes
 */
static void
set_user_modes(void)
{
	gSPSetGeometryMode(glistp++, G_SHADE | G_ZBUFFER);
	gSPTexture(glistp++, 0x8000, 0x8000, 0, G_TX_RENDERTILE, G_ON);

	if (ModeEn & M_RGBDITHER) {
		gDPSetColorDither(glistp++, G_CD_BAYER);
	} else {
		gDPSetColorDither(glistp++, G_CD_DISABLE);
	}

	if (ModeEn & M_BFCULL) {
		gSPSetGeometryMode(glistp++, G_CULL_BACK);
	} else {
		gSPClearGeometryMode(glistp++, G_CULL_BACK);
	}

	if (ModeEn & M_TEXPERSP) {
		gDPSetTexturePersp(glistp++, G_TP_PERSP);
	} else {
		gDPSetTexturePersp(glistp++, G_TP_NONE);
	}

	if (ModeEn & M_TEXBILERP) {
		gDPSetTextureFilter(glistp++, G_TF_BILERP);
	} else {
		gDPSetTextureFilter(glistp++, G_TF_POINT);
	}
}

/*
 *   Determine what to display
 */
static void
set_display(Dynamic * dynamicp)
{
	if (DisplayEn & D_MOUNTAINS)
		gSPDisplayList(glistp++, &(relax0_dl[0]));

	if (DisplayEn & D_POOL)
		gSPDisplayList(glistp++, &(relax1_dl[0]));

	if (DisplayEn & D_ORB) {
		gSPLookAt(glistp++, &(RSPdynamic.lookat[0]));
		gSPDisplayList(glistp++, ltsphere_att_dl);
		gDPSetHilite1Tile(glistp++, G_TX_RENDERTILE, dynamicp->hilite, 32, 32);
		gSPDisplayList(glistp++, ltsphere_dl);
	}

	if (DisplayEn & D_CLOCK) {
		gDPPipeSync(glistp++);
		gDPSetCycleType(glistp++, G_CYC_1CYCLE);
		gDPSetTexturePersp(glistp++, G_TP_NONE);
		do_clock(&glistp);
	}
}