/*
 *  NINTENDO64 SAMPLE PROGRAM
 *
 *  FILE : playseq.c (for 64DD)
 *
 *  Copyright (C) 1998, NINTENDO Co,Ltd.
 */


#include <ultra64.h>
#include <assert.h>
#include <PR/os.h>
#include <PR/ramrom.h>
#include <PR/gu.h>
#include <PR/leo.h>

#include "dd_audio.h"
#include "playseq.h"


/*
 * Threads
 */
u64	        bootStack[STACKSIZE/8];

static void	mainproc(u8 *);
static OSThread	mainThread;
static u64	mainThreadStack[STACKSIZE/8];

static void	gameproc(u8 *);
static OSThread	gameThread;
static u64	gameThreadStack[STACKSIZE/8];

/*
 * For PI manager
 */
static OSMesgQueue PiMessageQ;
static OSMesg      PiMessages[DMA_QUEUE_SIZE];

/*
 * For 64DD
 */
static OSMesgQueue diskQ;
static OSMesg      diskQBuf;

static OSMesg      LeoMessages[NUM_LEO_MESGS];

static LEODiskID   diskID;
static LEOCmd      cmdBlock;

void DiskInitialize(void);
void CheckDiskInsert(void);
s32  CheckDiskEject(void);
void DiskRead(u32, void *, u32);

/*
 * For synchronization
 */
static OSMesgQueue retraceMessageQ;
static OSMesg      retraceMessageBuf;

static OSMesgQueue taskMessageQ;
static OSMesg      taskMessageBuf;

static OSMesgQueue dmaMessageQ;
static OSMesg      dmaMessageBuf[DMA_QUEUE_SIZE];

static OSMesgQueue resetMessageQ;
static OSMesg      resetMessageBuf;

/*
 * For audio
 */
static ALGlobals g;
static u8        audioHeap[AUDIO_HEAP_SIZE];
static ALHeap    hp;

static ALSynConfig  c;
static ALSeqpConfig seqc;

static s32 curBuf = 0;
static s32 curAudioBuf = 1;

/*
 * Double-buffer
 */
static OSTask *tlist[2];
static Acmd   *cmdList[2];

/*
 * Triple-buffer
 */
static s16 audioSamples[3] = {0, 0, 0};
static s16 *audioBuffer[3];

/*
 * For vibrato and tremelo
 */
static ALMicroTime initOsc(void **oscState, f32 *initVal, u8 oscType,
                           u8 oscRate, u8 oscDepth, u8 oscDelay);
static ALMicroTime updateOsc(void *oscState, f32 *updateVal);
static void        stopOsc(void *oscState);

/*
 * For dma callback routine
 */
#define NBUFFERS 64

typedef struct 
{
    ALLink node;
    int    startAddr;
    u32    lastFrame;
    char   *ptr;
} DMABuffer;

typedef struct 
{
    u8        initialized;
    DMABuffer *firstUsed;
    DMABuffer *firstFree;

} DMAState;

static OSPiHandle *cartromHandle;
static OSPiHandle *driveromHandle;

static OSIoMesg dmaIOMesgBuf[DMA_QUEUE_SIZE];
static s32      nextDMA = 0;

DMAState  dmaState;
DMABuffer dmaBuffs[NBUFFERS];
u32       gFrameCt;


s32 dmaCallBack(s32 addr, s32 len, void *state)
{
    s32         
      delta,
      addrEnd,
      buffEnd;
    u32
      tmp;
    DMABuffer  
      *dmaPtr,
      *lastDmaPtr;
    void 
      *freeBuffer;
    OSPiHandle
      *piHandle;
    OSIoMesg
      *ioMesg;


    /* check address (device flag) */
    tmp = addr & DDROM_FLAG;

    /* When in DDROM */
    if(tmp == DDROM_FLAG) {

      piHandle = driveromHandle;
      addr &= 0x0fffffff;
    } 

    /* When in other media */
    else {

      /* When in RAM */
      if(tmp)
	return (osVirtualToPhysical((void *)addr));

      /* When in CARTRIDGE ROM */
#ifdef FINAL
      piHandle = cartromHandle;
#else
      osSyncPrintf("Error : Data in CARTRIDGE ROM\n");
#endif
    }


    lastDmaPtr = 0;
    dmaPtr = dmaState.firstUsed;
    addrEnd = addr+len;
 
    while(dmaPtr)  /* see if buffer is already set up */
    {

        buffEnd = dmaPtr->startAddr + MAX_BUFFER_LENGTH;
        if(dmaPtr->startAddr > addr) /* since buffers are ordered */
            break;                   /* abort if past possible */

        else if(addrEnd <= buffEnd) /* yes, found one */
        {
            dmaPtr->lastFrame = gFrameCt; /* mark it used */
            freeBuffer = dmaPtr->ptr + addr - dmaPtr->startAddr;
            return (int) osVirtualToPhysical(freeBuffer);
        }
        lastDmaPtr = dmaPtr;
        dmaPtr = (DMABuffer*)dmaPtr->node.next;
    }

    /* get here, and you didn't find a buffer, so dma a new one */

    /* get a buffer from the free list */
    dmaPtr = dmaState.firstFree;

    assert(dmaPtr);  /* be sure you have a buffer */

    dmaState.firstFree = (DMABuffer*)dmaPtr->node.next;
    alUnlink((ALLink*)dmaPtr);

    /* add it to the used list */
    if(lastDmaPtr) /* normal procedure */
    {
        alLink((ALLink*)dmaPtr,(ALLink*)lastDmaPtr);
    }
    else if(dmaState.firstUsed) /* jam at begining of list */
    {
        lastDmaPtr = dmaState.firstUsed;
        dmaState.firstUsed = dmaPtr;
        dmaPtr->node.next = (ALLink*)lastDmaPtr;
        dmaPtr->node.prev = 0;
        lastDmaPtr->node.prev = (ALLink*)dmaPtr;
    }
    else /* no buffers in list, this is the first one */
    {
        dmaState.firstUsed = dmaPtr;
        dmaPtr->node.next = 0;
        dmaPtr->node.prev = 0;
    }
    
    freeBuffer = dmaPtr->ptr;
    delta = addr & 0x1;
    addr -= delta;
    dmaPtr->startAddr = addr;
    dmaPtr->lastFrame = gFrameCt;  /* mark it */

    ioMesg = &dmaIOMesgBuf[nextDMA ++];

    ioMesg->hdr.pri      = OS_MESG_PRI_NORMAL;
    ioMesg->hdr.retQueue = &dmaMessageQ;
    ioMesg->dramAddr     = freeBuffer;
    ioMesg->devAddr      = addr;
    ioMesg->size         = MAX_BUFFER_LENGTH;
    
    if(tmp)
      piHandle->transferInfo.cmdType = OS_OTHERS;

    osEPiStartDma(piHandle, ioMesg, OS_READ);


    return (int) osVirtualToPhysical(freeBuffer) + delta;
}


ALDMAproc dmaNew(DMAState **state)
{
    int i;


    if(!dmaState.initialized)  /* only do this once */
    {
        dmaState.firstFree = &dmaBuffs[0];
        for (i=0; i<NBUFFERS-1; i++)
        {
            alLink((ALLink*)&dmaBuffs[i+1],(ALLink*)&dmaBuffs[i]);
            dmaBuffs[i].ptr = alHeapAlloc(&hp, 1, MAX_BUFFER_LENGTH);
        }

        dmaState.initialized = 1;
    }

    *state = &dmaState;  /* state is never used in this case */


    /* Initialize device handle */
    cartromHandle  = osCartRomInit();
    driveromHandle = osDriveRomInit();


    return dmaCallBack;
}


void CleanDMABuffs(void)
{
    DMABuffer
      *dmaPtr,
      *nextPtr;


    dmaPtr = dmaState.firstUsed;
    while(dmaPtr)
    {
        nextPtr = (DMABuffer*)dmaPtr->node.next;

        /* Can change this value.  Should be at least one.  */
        /* Larger values mean more buffers needed, but fewer DMA's */

        if(dmaPtr->lastFrame + 2  < gFrameCt) /* remove from used list */
        {
            if(dmaState.firstUsed == dmaPtr)
                dmaState.firstUsed = (DMABuffer*)dmaPtr->node.next;
            alUnlink((ALLink*)dmaPtr);
            if(dmaState.firstFree)
                alLink((ALLink*)dmaPtr,(ALLink*)dmaState.firstFree);
            else
            {
                dmaState.firstFree = dmaPtr;
                dmaPtr->node.next = 0;
                dmaPtr->node.prev = 0;
            }
        }
        dmaPtr = nextPtr;
    }
}


/***********************************************************************
 *    initOsc, updateOsc and stopOsc are callbacks used to implement
 *    LFO's for vibrato and tremelo. Type values are set in the bank.inst
 *    file, and should always be different between vibrato and tremelo.
 *    Your initOsc routine should then be able to distinguish based on this
 *    value whether the LFO is for tremelo or vibrato. The audio library
 *    does not use the type value to know, but uses a different method, so
 *    applications are free to use any values 1-255 for types. (A type of
 *    zero means no vibrato or no tremelo.) In the initOsc routine, the
 *    application initializes the oscillator, allocates memory for the
 *    oscState and stores a pointer to that memory in the oscState handle.
 *    This pointer will be handed back to the application at each updateOsc
 *    call. The initVal is a pointer to either a u8, when the osc is a tremelo
 *    oscillator, or a f32 when the oscillator is a vibrato oscillator.
 *    This value should always be set. In the case of tremelo oscillators,
 *    the u8 should be a volume value from 0-127.  In the case of the vibrato
 *    oscillator, the f32 is a ratio that the original pitch of the note should
 *    be multiplied by.  A ratio of 1.0 will produce unity pitch, while a value
 *    of 0.5 will produce one octave lower, and 2.0 will produce one octave higher.
 *    initOsc returns a deltaTime in microseconds until the first call to
 *    updateOsc. If a deltaTime of zero is returned the initVal will be used
 *    but no further calls to the oscillator will be made. When an updateOsc
 *    call occurs the application should do any necessary calculations to update
 *    the oscillator, set the value pointed to by updateVal, and return the
 *    time, in microseconds, until the next updateOsc call.  When a stopOsc
 *    call occurs, the application should do any necessary cleaning up, and
 *    freeing of memory. Given below are several examples of how to implement
 *    an LFO to control tremelo and vibrato.
 *****************************************************************************/

/**********************************************************************
 *    OscType may be assigned in any way suited to the application. In
 *    this example, oscType's are assigned as follows:
 *    oscType = 1     A tremelo that uses a sin function
 *    oscType = 2     A tremelo that uses a square wave
 *    oscType = 3     A tremelo that uses a descending sawtooth
 *    oscType = 4     A tremelo that uses an ascending sawtooth
 *    oscType = 128   A vibrato that uses a sin function
 *    oscType = 129   A vibrato that uses a square wave
 *    oscType = 130   A vibrato that uses a descending sawtooth
 *    oscType = 131   A vibrato that uses an ascending sawtooth
 **********************************************************************/

#define  TREMELO_SIN        1
#define  TREMELO_SQR        2
#define  TREMELO_DSC_SAW    3
#define  TREMELO_ASC_SAW    4
#define  VIBRATO_SIN        128
#define  VIBRATO_SQR        129
#define  VIBRATO_DSC_SAW    130
#define  VIBRATO_ASC_SAW    131

#define  OSC_HIGH   0
#define  OSC_LOW    1
#define  TWO_PI     6.2831853

/*****************************************************************************
 *   oscDepth, oscRate and oscDelay may be used in anyway deemed appropriate
 *   by the programmer. These values are not used by the sequence player, but
 *   merely passed to the init routine. In this example, oscDelay is converted
 *   to microseconds by multiplying by 0x4000. But many other methods could have
 *   been chosen. In the vibrato examples, oscDepth is converted by the routine
 *   _depth2Cents.  Cents can then easily be converted to ratio. For the tremelo
 *   examples, oscDepth is the max depth on the volume scale of 0-127. Sin
 *   oscillators are implemented using the sinf() library call.
 *****************************************************************************/

typedef struct {  
    u8      rate;
    u8      depth;
    u8      oscCount;
} defData;

typedef struct {
    u8      halfdepth;
    u8      baseVol;
} tremSinData;
    
typedef struct {
    u8      curVal;
    u8      hiVal;
    u8      loVal;
} tremSqrData;

typedef struct {
    u8      baseVol;
    u8      depth;
} tremSawData;
    
typedef struct {
    f32     depthcents;
} vibSinData;

typedef struct {
    f32     loRatio;
    f32     hiRatio;
} vibSqrData;

typedef struct {
    s32     hicents;
    s32     centsrange;
} vibDSawData;

typedef struct {
    s32     locents;
    s32     centsrange;
} vibASawData;

typedef struct oscData_s {
    struct oscData_s  *next;
    u8      type;
    u8      stateFlags;
    u16     maxCount;
    u16     curCount;
    union {
        defData         def;
        tremSinData     tsin;
        tremSqrData     tsqr;
        tremSawData     tsaw;
        vibSinData      vsin;
        vibSqrData      vsqr;
        vibDSawData     vdsaw;
        vibASawData     vasaw;
    } data;        
} oscData;

/*
 * Number of osc states needed. In worst case will need two for each
 * voice. But if tremelo and vibrato not used on all instruments will
 * need less.
 */
#define  OSC_STATE_COUNT    2*MAX_VOICES 
oscData  *freeOscStateList;
oscData  oscStates[OSC_STATE_COUNT];


/************************************************************************
 *   _depth2Cents()  convert a u8 (0-255) to a cents value. Convert using
 *   1.03099303^(depth). This gives an exponential range of values from
 *   1 to 2400.  (2400 cents is 2 octaves). Lots of small values for
 *   good control of depth in musical applications, and a couple of
 *   really broad ranges for special effects.
 ************************************************************************/
f32 _depth2Cents(u8 depth)
{
    f32     x = 1.03099303;
    f32     cents = 1.0;

    while(depth)
    {
        if(depth & 1)
            cents *= x;
        x *= x;
        depth >>= 1;
    }

    return(cents);
}


ALMicroTime initOsc(void **oscState, f32 *initVal,u8 oscType,
                    u8 oscRate,u8 oscDepth,u8 oscDelay)
{
    oscData         *statePtr;
    ALMicroTime     deltaTime = 0;


    if(freeOscStateList)  /* yes there are oscStates available */
    {
        statePtr = freeOscStateList;
        freeOscStateList = freeOscStateList->next;
        statePtr->type = oscType;
        *oscState = statePtr;

        /*
         * Convert delay into usec's, In this example, multiply by
         * 0x4000, but could easily use another conversion method.
         */
        deltaTime = oscDelay * 0x4000;

        switch(oscType) /* set the initVal */
        {
            case TREMELO_SIN:
                statePtr->curCount = 0;
                statePtr->maxCount = 259-oscRate; /* gives values 4-259 */
                statePtr->data.tsin.halfdepth = oscDepth >> 1;
                statePtr->data.tsin.baseVol = AL_VOL_FULL - statePtr->data.tsin.halfdepth;
                *initVal = (f32)statePtr->data.tsin.baseVol;
                break;

            case TREMELO_SQR:
                statePtr->maxCount = 256-oscRate; /* values from 1-256 */
                statePtr->curCount = statePtr->maxCount;
                statePtr->stateFlags = OSC_HIGH;
                statePtr->data.tsqr.loVal = AL_VOL_FULL-oscDepth;
                statePtr->data.tsqr.hiVal = AL_VOL_FULL;
                statePtr->data.tsqr.curVal = AL_VOL_FULL;
                *initVal = (f32)AL_VOL_FULL;
                break;

            case TREMELO_DSC_SAW:
                statePtr->maxCount = 256-oscRate;
                statePtr->curCount = 0;
                statePtr->data.tsaw.depth = oscDepth;
                statePtr->data.tsaw.baseVol = AL_VOL_FULL;
                *initVal = (f32)statePtr->data.tsaw.baseVol;
                break;

            case TREMELO_ASC_SAW: 
                statePtr->maxCount = 256-oscRate;
                statePtr->curCount = 0;
                statePtr->data.tsaw.depth = oscDepth;
                statePtr->data.tsaw.baseVol = AL_VOL_FULL - oscDepth;
                *initVal = (f32)statePtr->data.tsaw.baseVol;
                break;           

            case VIBRATO_SIN:
                statePtr->data.vsin.depthcents = _depth2Cents(oscDepth);
                statePtr->curCount = 0;
                statePtr->maxCount = 259-oscRate; /* gives values 4-259 */
                *initVal = 1.0f; /* start at unity pitch */
                break;

            case VIBRATO_SQR:
                {
                    s32     cents;
                    statePtr->maxCount = 256-oscRate; /* values from 1-256 */
                    statePtr->curCount = statePtr->maxCount;
                    statePtr->stateFlags = OSC_HIGH;
                    cents = _depth2Cents(oscDepth);
                    statePtr->data.vsqr.loRatio = alCents2Ratio(-cents);
                    statePtr->data.vsqr.hiRatio = alCents2Ratio(cents);
                    *initVal = statePtr->data.vsqr.hiRatio;
                }
                break;
                    
            case VIBRATO_DSC_SAW:
                {
                    s32     cents;
                    statePtr->maxCount = 256-oscRate; /* values from 1-256 */
                    statePtr->curCount = statePtr->maxCount;
                    cents = _depth2Cents(oscDepth);
                    statePtr->data.vdsaw.hicents = cents;
                    statePtr->data.vdsaw.centsrange = 2 * cents;
                    *initVal = alCents2Ratio(statePtr->data.vdsaw.hicents);
                }
                break;
                
            case VIBRATO_ASC_SAW:
                {
                    s32     cents;
                    statePtr->maxCount = 256-oscRate; /* values from 1-256 */
                    statePtr->curCount = statePtr->maxCount;
                    cents = _depth2Cents(oscDepth);
                    statePtr->data.vasaw.locents = -cents;
                    statePtr->data.vasaw.centsrange = 2 * cents;
                    *initVal = alCents2Ratio(statePtr->data.vasaw.locents);
                }
                break;

        }
    }
    return(deltaTime);  /* if there are no oscStates, return zero, but if
                           oscState was available, return delay in usecs */
}


ALMicroTime updateOsc(void *oscState, f32 *updateVal)
{
    f32             tmpFlt;
    oscData         *statePtr = (oscData*)oscState;
    ALMicroTime     deltaTime = AL_USEC_PER_FRAME; /* in this example callback every */
                                              /* frame, but could be at any interval */

    switch(statePtr->type)   /* perform update calculations */
    {
        case TREMELO_SIN:
            statePtr->curCount++;
            if(statePtr->curCount >= statePtr->maxCount)
                statePtr->curCount = 0;
            tmpFlt = (f32)statePtr->curCount / (f32)statePtr->maxCount;
            tmpFlt = sinf(tmpFlt*TWO_PI);
            tmpFlt = tmpFlt * (f32)statePtr->data.tsin.halfdepth;
            *updateVal = (f32)statePtr->data.tsin.baseVol + tmpFlt;
            break;

        case TREMELO_SQR:
            if(statePtr->stateFlags == OSC_HIGH)
            {
                *updateVal = (f32)statePtr->data.tsqr.loVal;
                statePtr->stateFlags = OSC_LOW;
            }
            else
            {
                *updateVal = (f32)statePtr->data.tsqr.hiVal;
                statePtr->stateFlags = OSC_HIGH;
            }
            deltaTime *= statePtr->maxCount;
            break;
            
        case TREMELO_DSC_SAW:
            statePtr->curCount++;
            if(statePtr->curCount > statePtr->maxCount)
                statePtr->curCount = 0;
            
            tmpFlt = (f32)statePtr->curCount / (f32)statePtr->maxCount;
            tmpFlt *= (f32)statePtr->data.tsaw.depth;
            *updateVal = (f32)statePtr->data.tsaw.baseVol - tmpFlt;
            break;
            
        case TREMELO_ASC_SAW: 
            statePtr->curCount++;
            if(statePtr->curCount > statePtr->maxCount)
                statePtr->curCount = 0;
            tmpFlt = (f32)statePtr->curCount / (f32)statePtr->maxCount;
            tmpFlt *= (f32)statePtr->data.tsaw.depth;
            *updateVal = (f32)statePtr->data.tsaw.baseVol + tmpFlt;
            break;

        case VIBRATO_SIN:
            /* calculate a sin value (from -1 to 1) and multiply it by depthcents.
               Then convert cents to ratio. */

            statePtr->curCount++;
            if(statePtr->curCount >= statePtr->maxCount)
                statePtr->curCount = 0;
            tmpFlt = (f32)statePtr->curCount / (f32)statePtr->maxCount;
            tmpFlt = sinf(tmpFlt*TWO_PI) * statePtr->data.vsin.depthcents;
            *updateVal = alCents2Ratio((s32)tmpFlt);
            break;
            
        case VIBRATO_SQR:
            if(statePtr->stateFlags == OSC_HIGH)
            {
                statePtr->stateFlags = OSC_LOW;
                *updateVal = statePtr->data.vsqr.loRatio;
            }
            else
            {
                statePtr->stateFlags = OSC_HIGH;
                *updateVal = statePtr->data.vsqr.hiRatio;
            }
            deltaTime *= statePtr->maxCount;
            break;

        case VIBRATO_DSC_SAW:
            statePtr->curCount++;
            if(statePtr->curCount > statePtr->maxCount)
                statePtr->curCount = 0;
            tmpFlt = (f32)statePtr->curCount / (f32)statePtr->maxCount;
            tmpFlt *= (f32)statePtr->data.vdsaw.centsrange;
            tmpFlt = (f32)statePtr->data.vdsaw.hicents - tmpFlt;
            *updateVal = alCents2Ratio((s32)tmpFlt);
            break;
            
        case VIBRATO_ASC_SAW:
            statePtr->curCount++;
            if(statePtr->curCount > statePtr->maxCount)
                statePtr->curCount = 0;
            tmpFlt = (f32)statePtr->curCount / (f32)statePtr->maxCount;
            tmpFlt *= (f32)statePtr->data.vasaw.centsrange;
            tmpFlt += (f32)statePtr->data.vasaw.locents;
            *updateVal = alCents2Ratio((s32)tmpFlt);
            break;
    }
    
    return(deltaTime);
}


void stopOsc(void *oscState)
{
    ((oscData*)oscState)->next = freeOscStateList;
    freeOscStateList = (oscData*)oscState;
}


/*
 * BOOT
 */
boot(void *arg)
{
    osInitialize();

    osCreateThread(&mainThread, 1, (void(*)(void *))mainproc, arg,
		  ((u8 *) mainThreadStack) + STACKSIZE, 10);
    osStartThread(&mainThread);
}


/*
 * Idle thread
 */
static void mainproc(u8 *argv) 
{

    /*
     * Initialize video
     */
    osCreateViManager(OS_PRIORITY_VIMGR);
    osViSetMode(&osViModeTable[OS_VI_NTSC_LAN1]);

    /*
     * Start PI Manager
     */
    osCreatePiManager((OSPri) 150, &PiMessageQ, PiMessages, DMA_QUEUE_SIZE);

    /*
     * Create and start game(main) thread
     */
    osCreateThread(&gameThread, 3, (void(*)(void *))gameproc, argv,
                                 ((u8 *) gameThreadStack) + STACKSIZE, 10);
    osStartThread(&gameThread);

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


/*
 * Main(game) thread
 */
static void gameproc(u8 *argv)
{
    ALCSPlayer
        sequencePlayer,
        *seqp = &sequencePlayer;

    ALCSeq
        sequence,
        *seq = &sequence;

    ALBank
        *waveBank;

    Acmd
        *cmdlp;

    OSTask
        *tlistp;

    s16
        *audioOp;

    s32
        frameSize,
        minFrameSize,
        buf,
        clcount,
        samplesLeft = 0;

    u32
        i,
        tmp_u32;

    f32
        fsize;

    oscData
        *oscStatePtr;
    

    /*
     * Message queue for PI manager return messages
     */
    osCreateMesgQueue(&dmaMessageQ, dmaMessageBuf, DMA_QUEUE_SIZE);

    /*
     * Set up message queue for TASK interrupts
     */
    osCreateMesgQueue(&taskMessageQ, &taskMessageBuf, 1);
    osSetEventMesg(OS_EVENT_SP, &taskMessageQ, NULL);

    osSendMesg(&taskMessageQ, NULL, OS_MESG_BLOCK);

    /*
     * Set up message queue for video interrupts
     */
    osCreateMesgQueue(&retraceMessageQ, &retraceMessageBuf, 1);
    osViSetEvent(&retraceMessageQ, NULL, NUM_FIELDS);
    
    /*
     * Set up message queue for preNMI interrupts
     */
    osCreateMesgQueue(&resetMessageQ, &resetMessageBuf, 1);
    osSetEventMesg(OS_EVENT_PRENMI, &resetMessageQ, NULL);

    /*
     * Audio heap
     */
    alHeapInit(&hp, (u8 *) audioHeap, AUDIO_HEAP_SIZE);

    /*
     * Allocate storage for command list and task headers
     */
    cmdList[0] = alHeapAlloc(&hp, 1, MAX_CLIST_SIZE*sizeof(Acmd));
    cmdList[1] = alHeapAlloc(&hp, 1, MAX_CLIST_SIZE*sizeof(Acmd));

    tlist[0] = alHeapAlloc(&hp, 1, sizeof(OSTask));
    tlist[1] = alHeapAlloc(&hp, 1, sizeof(OSTask));

    audioBuffer[0] = alHeapAlloc(&hp, 1, sizeof(s32)*MAX_AUDIO_LENGTH);
    audioBuffer[1] = alHeapAlloc(&hp, 1, sizeof(s32)*MAX_AUDIO_LENGTH);
    audioBuffer[2] = alHeapAlloc(&hp, 1, sizeof(s32)*MAX_AUDIO_LENGTH);

    /*
     * Initialize 64DD
     */
    DiskInitialize();

    /*
     * Read .ctl file
     */
    tmp_u32 = (u32)_wavebankSegmentDiskEnd - (u32)_wavebankSegmentDiskStart;
    DiskRead((u32)_wavebankSegmentDiskStart, waveBankFile, tmp_u32);

    /*
     * Read .tbl file
     */
    tmp_u32 = (u32)_wavetableSegmentDiskEnd - (u32)_wavetableSegmentDiskStart;
    DiskRead((u32)_wavetableSegmentDiskStart, waveTableFile, tmp_u32);

    dd_alBnkfNew((ALBankFile *)waveBankFile, (u8 *)waveTableFile);
    waveBank = ((ALBankFile *)waveBankFile)->bankArray[0];

    /*
     * Read sequence data
     */
    tmp_u32 = (u32)_seqSegmentDiskEnd - (u32)_seqSegmentDiskStart;
    DiskRead((u32)_seqSegmentDiskStart, seqData, tmp_u32);

    /*
     * Initialize DAC output rate
     */
    c.outputRate = osAiSetFrequency(OUTPUT_RATE);

    fsize = (f32) NUM_FIELDS * c.outputRate / (f32) 60;
    frameSize = (s32) fsize;
    if (frameSize < fsize)
        frameSize++;
    if (frameSize & 0xf)
        frameSize = (frameSize & ~0xf) + 0x10;
    minFrameSize = frameSize - 16;

    /*
     * Audio synthesizer initialization
     */
    c.maxVVoices = MAX_VOICES;
    c.maxPVoices = MAX_VOICES;
    c.maxUpdates = MAX_UPDATES;
    c.dmaproc    = &dmaNew;
    c.heap       = &hp;
    c.fxType	 = AL_FX_SMALLROOM;

    alInit(&g, &c);

    /*
     * For vibrato and tremelo
     */
    freeOscStateList = &oscStates[0];
    oscStatePtr = &oscStates[0];
    for(i=0;i<(OSC_STATE_COUNT-1);i++)
    {
        oscStatePtr->next = &oscStates[i+1];
        oscStatePtr = oscStatePtr->next;
    }
    oscStatePtr->next = 0;  /* set last pointer to zero */
    
    /*
     * Sequence player initialization 
     */
    seqc.maxVoices      = MAX_VOICES;
    seqc.maxEvents      = EVT_COUNT;
    seqc.maxChannels    = 16;
    seqc.heap           = &hp;
    seqc.initOsc        = &initOsc;
    seqc.updateOsc      = &updateOsc;
    seqc.stopOsc        = &stopOsc;
#ifdef _DEBUG
    seqc.debugFlags     = NO_VOICE_ERR_MASK |NOTE_OFF_ERR_MASK | NO_SOUND_ERR_MASK;
#endif

    alCSPNew(seqp, &seqc);

    /*
     * Allocate wavebank and sequence data
     */
    alCSPSetBank(seqp, waveBank);
    alCSeqNew(seq, seqData);
    alCSPSetSeq(seqp, seq);

    /*
     * Main loop 
     */
    while (1){

        alCSPPlay(seqp);

        /*
         * Sync up on vertical retrace - read more than 1 to be sure!
         */
        (void)osRecvMesg(&retraceMessageQ, NULL, OS_MESG_BLOCK);
        (void)osRecvMesg(&retraceMessageQ, NULL, OS_MESG_BLOCK);

	/*
	 * Note that this must be a do-while in order for seqp's state to
	 * get updated during the alAudioFrame processing.
	 */
       do {

            /*
             * Where the task list goes in DRAM
             */
            tlistp = tlist[curBuf];
            cmdlp = cmdList[curBuf];       

            /*
             * Where the audio goes in DRAM
             */
            buf = curAudioBuf % 3;
            audioOp = (s16 *) osVirtualToPhysical(audioBuffer[buf]);
            audioSamples[buf] = 16 + (frameSize - samplesLeft + EXTRA_SAMPLES) & ~0xf;
            if (audioSamples[buf] < minFrameSize)
                audioSamples[buf] = minFrameSize;

            /*
             * Call the frame handler
             */
            cmdlp = alAudioFrame(cmdlp, &clcount, audioOp, audioSamples[buf]);
            
            /*
             * Build the audio task
             */       
            tlistp->t.type            = M_AUDTASK;
            tlistp->t.flags           = 0x0;
            tlistp->t.ucode_boot      = (u64 *)rspbootTextStart;
            tlistp->t.ucode_boot_size = ((s32)rspbootTextEnd -
                                         (s32)rspbootTextStart);
            tlistp->t.ucode           = (u64 *) aspMainTextStart;
            tlistp->t.ucode_size      = SP_UCODE_SIZE;
            tlistp->t.ucode_data      = (u64 *) aspMainDataStart;
            tlistp->t.ucode_data_size = SP_UCODE_DATA_SIZE;
            tlistp->t.data_ptr        = (u64 *) cmdList[curBuf];
            tlistp->t.data_size       = (cmdlp - cmdList[curBuf]) * sizeof(Acmd);
            
            /*
             * Video does nothing - just syncs up on the frame boundary.
             */
            (void)osRecvMesg(&retraceMessageQ, NULL, OS_MESG_BLOCK);

            /*
             * Find out how many samples left in the currently running
             * audio buffer
             */
            samplesLeft = IO_READ(AI_LEN_REG)>>2;

            /*
             * The last task should have finished before the frame message
             * so this just clears the message queue
             */
            (void)osRecvMesg(&taskMessageQ, NULL, OS_MESG_BLOCK);

            /*
             * Point the DAC at the next buffer
             */
            buf = (curAudioBuf-1) % 3;

            osAiSetNextBuffer(audioBuffer[buf], audioSamples[buf]<<2);

            /*
             * Empty the dma queue to make sure all DMAs have completed.
             * If the app blocks here it is a bug since resources must
             * be managed so that all DMAs complete.
             */
            for (i=0; i<nextDMA; i++)
                if (osRecvMesg(&dmaMessageQ, NULL, OS_MESG_NOBLOCK) == -1)
                    osSyncPrintf("Dma not done\n");

            /*
             * Flush the cache and start task on RSP
             */
            osWritebackDCacheAll();
            osSpTaskStart(tlistp);

            CleanDMABuffs();

	    /*
	     * Check preNMI
	     */
	    if(!osRecvMesg(&resetMessageQ, NULL, OS_MESG_NOBLOCK))
	      LeoReset();

            /*
             * Swap buffers for wavetable storage and output
             */
            gFrameCt++;
            curBuf ^= 1; 
            curAudioBuf++; 
            nextDMA = 0;

        } while (seqp->state != AL_STOPPED);

	alCSeqNew(seq, seqData);
    }

    alCSPStop(seqp);
    alClose(&g);
}


/*
 * Initialize 64DD
 */
void DiskInitialize(void)
{
  s32
    error;


  osCreateMesgQueue(&diskQ, &diskQBuf, 1);
  error = LeoCreateLeoManager((OSPri)OS_PRIORITY_LEOMGR - 1,
			      (OSPri)OS_PRIORITY_LEOMGR,
			      LeoMessages, NUM_LEO_MESGS);

  if(error == LEO_ERROR_DEVICE_COMMUNICATION_FAILURE){
    osSyncPrintf("Error %d\n", error);
    osSyncPrintf("Please read 64DD manual.\n");
    for(;;);
  }
    
  CheckDiskInsert();

  if(bcmp((void *)&leoBootID, (void *)&diskID, sizeof(LEODiskID))){
    osSyncPrintf("You insert a bad disk. Please reboot 64DD.\n");
    for(;;);
  }

}


/*
 * Disk insert check
 */
void CheckDiskInsert(void)
{
  s32
    loop_flag = 1,
    error,
    old_error = -100;
    

  do {

    LeoReadDiskID(&cmdBlock, &diskID, &diskQ);
    osRecvMesg(&diskQ, (OSMesg *)&error, OS_MESG_BLOCK);
      
    switch(error) {
      
    case LEO_ERROR_GOOD:
      loop_flag = 0;
      break;
	
    case LEO_ERROR_QUEUE_FULL:
      break;
	
    case LEO_ERROR_EJECTED_ILLEGALLY_RESUME:
      if(error != old_error){
	osSyncPrintf("Error %d\n", error);
	osSyncPrintf("Please don't eject the disk when the accsess-lamp is blinking.\n");
      }
      break;

    case LEO_ERROR_MEDIUM_NOT_PRESENT:
      if(error != old_error){
	osSyncPrintf("Error %d\n", error);
	osSyncPrintf("Please insert a disk.\n");
      }
      break;

    case LEO_ERROR_INCOMPATIBLE_MEDIUM_INSTALLED:
      osSyncPrintf("Error %d\n", error);
      osSyncPrintf("Please read 64DD manual.\n");
      while(!CheckDiskEject());
      break;

    case LEO_ERROR_DIAGNOSTIC_FAILURE:
      osSyncPrintf("Error %d\n", error);
      osSyncPrintf("Please eject the disk and then insert it again.\n");
      while(!CheckDiskEject());
      break;

    case LEO_ERROR_COMMAND_TERMINATED:
    default:
      osSyncPrintf("Error %d\n", error);
      osSyncPrintf("Please read 64DD manual.\n");
      for(;;);
    }

    old_error = error;
    
  } while(loop_flag);

}


/*
 * Disk eject check
 */
s32 CheckDiskEject(void) 
{
  s32
    loop_flag = 1,
    error;


  do {

    LeoSpdlMotor(&cmdBlock, LEO_MOTOR_SLEEP, &diskQ);
    osRecvMesg(&diskQ, (OSMesg *)&error, OS_MESG_BLOCK);

    switch(error){

    case LEO_ERROR_GOOD:
    case LEO_ERROR_DIAGNOSTIC_FAILURE:
      error = 0;

    case LEO_ERROR_MEDIUM_NOT_PRESENT:
    case LEO_ERROR_MEDIUM_MAY_HAVE_CHANGED:
    case LEO_ERROR_EJECTED_ILLEGALLY_RESUME:
      loop_flag = 0;
      break;

    case LEO_ERROR_QUEUE_FULL:
      break;

    case LEO_ERROR_COMMAND_TERMINATED:
    default:
      osSyncPrintf("Error %d\n", error);
      osSyncPrintf("Please read 64DD manual.\n");
      for(;;);
    }

  } while(loop_flag);

  return error;
}


/*
 * Read disk (only)
 */
void DiskRead(u32 srcLBA, void *destDRAM, u32 nLBAs)
{
  s32
    loop_flag = 1,
    error;


  do {

    osWritebackDCacheAll();
    LeoReadWrite(&cmdBlock, 
		 OS_READ,
		 srcLBA,
		 destDRAM,
		 nLBAs, 
		 &diskQ);
    osRecvMesg(&diskQ, (OSMesg *)&error, OS_MESG_BLOCK);

    switch(error){

    case LEO_ERROR_GOOD:
      loop_flag = 0;
      break;
	
    case LEO_ERROR_QUEUE_FULL:
      break;
	
    case LEO_ERROR_DIAGNOSTIC_FAILURE:
      osSyncPrintf("Error %d\n", error);
      osSyncPrintf("Please eject the disk and then insert it again.\n");

      do {
	while(!CheckDiskEject());

	CheckDiskInsert();

	if(bcmp((void *)&leoBootID, (void *)&diskID, sizeof(LEODiskID)))
	  osSyncPrintf("You insert a bad disk. Please check the disk.\n");
	else
	  break;

      } while(1);
      break;

    case LEO_ERROR_EJECTED_ILLEGALLY_RESUME:
    case LEO_ERROR_MEDIUM_NOT_PRESENT:
      osSyncPrintf("Error %d\n", error);
      if(error == LEO_ERROR_EJECTED_ILLEGALLY_RESUME)
	osSyncPrintf("Please don't eject the disk when the accsess-lamp is blinking.\n");
      else
	osSyncPrintf("Please insert a disk.\n");

    case LEO_ERROR_MEDIUM_MAY_HAVE_CHANGED:
      do {
	CheckDiskInsert();
	
	if(!bcmp((void *)&leoBootID, (void *)&diskID, sizeof(LEODiskID)))
	  break;

	osSyncPrintf("You insert a bad disk. Please check the disk.\n");

	while(!CheckDiskEject());

      } while(1);
      break;

    case LEO_ERROR_COMMAND_TERMINATED:
    default:
      osSyncPrintf("Error %d\n", error);
      osSyncPrintf("Please read 64DD manual.\n");
      for(;;);
    }

  } while(loop_flag);

}