/*====================================================================
 * seqpActions.c
 *
 * Synopsis:
 *
 * Player for testing of driver functions
 *
 * Copyright 1993, Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics,
 * Inc.; the contents of this file may not be disclosed to third
 * parties, copied or duplicated in any form, in whole or in part,
 * without the prior written permission of Silicon Graphics, Inc.
 *
 * RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to
 * restrictions as set forth in subdivision (c)(1)(ii) of the Rights
 * in Technical Data and Computer Software clause at DFARS
 * 252.227-7013, and/or in similar or successor clauses in the FAR,
 * DOD or NASA FAR Supplement. Unpublished - rights reserved under the
 * Copyright Laws of the United States.
 *====================================================================*/

#include <libaudio.h>
#include <stdio.h>
#include <assert.h>
#include "audiotest.h"		/* romCopy */
#include "audio.h"
#include "seqpActions.h"
#include "UniversalSP.h"


#define MIN_TIME        0
#define MAX_TIME        10000
#define MAX_INT         0x7fffffff
#define MAX_SHORT       0x7fff


#define VERBOSE		1
#if VERBOSE
    #define MaybePRINTF	PRINTF
#else
    #define MaybePRINTF	NULL
#endif

extern ALHeap		gHeapRec;
extern ALBankFile *	gBankFile;
extern ALSeqFile *	gSeqFile;
extern ALUSPlayer *	gSeqp;
extern ALUSeq *		gSeq;
extern u8 *		gSeqData;

static char		sHasBank;

static void	__GetRandomSeq (ALUSeq **ppSeq);
static void	__GetRandomBank (ALBank **ppBank);
static s32	__GetNumVoices (void);


char
actNull (void)
{
    MaybePRINTF("\tnull\n");
    return TRUE;
}


char
actDone (void)
{
    MaybePRINTF("\tdone\n");
    return TRUE;
}


char
actSeqpNew (void) 
{
    ALSeqpConfig        seqc;

    MaybePRINTF("\tnew seqp\n");

    seqc.maxVoices      = MAX_SEQP_VOICES;
    seqc.maxEvents      = MAX_SEQP_EVENTS;
    seqc.maxChannels    = 16;
    seqc.heap           = &gHeapRec;
    seqc.initOsc        = 0;
    seqc.updateOsc      = 0;
    seqc.stopOsc        = 0;
#ifdef _DEBUG
    seqc.debugFlags     = NO_VOICE_ERR_MASK |NOTE_OFF_ERR_MASK | NO_SOUND_ERR_MASK;
#endif

    alUSPNew(gSeqp, &seqc);

    sHasBank = FALSE;

    return TRUE;
}


char
actSeqpDelete (void)
{
    MaybePRINTF("\tdelete seqp\n");
    alUSPDelete (gSeqp);
    return TRUE;
}


char
actSeqpSetNonNULLSeq (void)
{
    ALUSeq *	pSeq;

    MaybePRINTF("\tset seq\n");
    __GetRandomSeq (&pSeq);		/* This may set pSeq to be a NULL sequence. */
    alUSPSetSeq (gSeqp, pSeq);

    return TRUE;
}


char
actSeqpSetMaybeNULLSeq (void)
{
    ALUSeq *	pSeq;

    MaybePRINTF("\tset seq\n");
    if (GetRandomNumber (0, 4))
	__GetRandomSeq (&pSeq);
    else
	pSeq = NULL;
    alUSPSetSeq (gSeqp, pSeq);

    return TRUE;
}


char
actSeqpGetSeq (void)
{
    ALUSeq *	pSeq;

    MaybePRINTF("\tget seq\n");
    pSeq = alUSPGetSeq (gSeqp);
    return TRUE;
}


char
actSeqpSetBank (void)
{
    ALBank *	pBank;

    if (alUSPGetState (gSeqp) == AL_STOPPED)
    {
	MaybePRINTF("\tset bank\n");
	__GetRandomBank (&pBank);
	alUSPSetBank (gSeqp, pBank);
	sHasBank = TRUE;
    }
    else
	MaybePRINTF("\tcan't set bank\n");

    return TRUE;
}


char
actSeqpPlay (void)
{
    if (sHasBank)
    {
	MaybePRINTF("\tplay:%d\n", __GetNumVoices ());

#ifndef COMP_SEQ_PLAY
	if (gSeq->curPtr - gSeq->base >= gSeq->len)
	    MaybePRINTF("\tEND OF SEQUENCE\n");
#endif

	alUSPPlay (gSeqp);
	return TRUE;
    }
    else
    {
	MaybePRINTF("\tcan't play\n");
	return FALSE;
    }
}


char
actSeqpStop (void)
{
    MaybePRINTF("\tstop\n");
    alUSPStop (gSeqp);
    return TRUE;
}


char
actSeqpGetState (void)
{
    s32 state = alUSPGetState (gSeqp);
    MaybePRINTF("\tget state:%s\n",
		 state == AL_STOPPED ? "AL_STOPPED" :
		 state == AL_PLAYING ? "AL_PLAYING" : "AL_STOPPING");
    return TRUE;
}


char
actSeqpSetTempo (void)
{
    s32 tempo = GetRandomNumber (500000-200000, 500000+100000);

    alUSPSetTempo (gSeqp, tempo);
    MaybePRINTF("\tset tempo: 0x%0x\n", tempo);

    return TRUE;
}


char
actSeqpGetTempo (void)
{
    s32 tempo;

    tempo = alUSPGetTempo (gSeqp);
    MaybePRINTF("\tget tempo: 0x%0x\n", tempo);

    return TRUE;
}


char
actSeqpSetPriority (void)
{
    u8 chan = GetRandomNumber (1, 16);
    u8 priority = GetRandomNumber (0, 127);

    alUSPSetChlPriority (gSeqp, chan, priority);
    MaybePRINTF("\tset chl priority: %d %d\n", chan, priority);

    return TRUE;
}


char
actSeqpGetPriority (void)
{
    u8 chan = GetRandomNumber (1, 16);
    u8 priority;

    priority = alUSPGetChlPriority (gSeqp, chan);
    MaybePRINTF("\tget chl priority: %d %d\n", chan, priority);

    return TRUE;
}


char
actSeqpSetProgram (void)
{
    u8 chan = GetRandomNumber (1, 16);
    u8 program = GetRandomNumber (0, 127);

    if (sHasBank)
    {
	alUSPSetChlProgram (gSeqp, chan, program);
	MaybePRINTF("\tset chl program: %d %d\n", chan, program);
    }

    return TRUE;
}


char
actSeqpGetProgram (void)
{
    u8 chan = GetRandomNumber (1, 16);
    u8 program;

    program = alUSPGetChlProgram (gSeqp, chan);
    MaybePRINTF("\tget chl program: %d %d\n", chan, program);

    return TRUE;
}


char
actSeqpSetFXMix (void)
{
    u8 chan = GetRandomNumber (1, 16);
    u8 fxmix = GetRandomNumber (0, 127);

    alUSPSetChlFXMix (gSeqp, chan, fxmix);
    MaybePRINTF("\tset chl fxmix: %d %d\n", chan, fxmix);

    return TRUE;
}


char
actSeqpGetFXMix (void)
{
    u8 chan = GetRandomNumber (1, 16);
    u8 fxmix;

    fxmix = alUSPGetChlFXMix (gSeqp, chan);
    MaybePRINTF("\tget chl fxmix: %d %d\n", chan, fxmix);

    return TRUE;
}


char
actSeqpSetChlVol (void)
{
    u8 chan = GetRandomNumber (1, 16);
    u8 vol = GetRandomNumber (0, 127);

    alUSPSetChlVol (gSeqp, chan, vol);
    MaybePRINTF("\tset chl vol: %d %d\n", chan, vol);

    return TRUE;
}


char
actSeqpGetChlVol (void)
{
    u8 chan = GetRandomNumber (1, 16);
    u8 vol;

    vol = alUSPGetChlVol (gSeqp, chan);
    MaybePRINTF("\tget chl vol: %d %d\n", chan, vol);

    return TRUE;
}


char
actSeqpSetPan (void)
{
    u8 chan = GetRandomNumber (1, 16);
    ALPan pan = GetRandomNumber (0, 127);

    alUSPSetChlPan (gSeqp, chan, pan);
    MaybePRINTF("\tset chl pan: %d %d\n", chan, pan);

    return TRUE;
}


char
actSeqpGetPan (void)
{
    u8 chan = GetRandomNumber (1, 16);
    ALPan pan;

    pan = alUSPGetChlPan (gSeqp, chan);
    MaybePRINTF("\tget chl pan: %d %d\n", chan, pan);

    return TRUE;
}


char
actSeqpSetVol (void)
{
    s16 vol = GetRandomNumber (0, MAX_SHORT);

    alUSPSetVol (gSeqp, vol);
    MaybePRINTF("\tset vol: %x\n", vol);

    return TRUE;
}


char
actSeqpGetVol (void)
{
    s16 vol;

    vol = alUSPGetVol (gSeqp);
    MaybePRINTF("\tget vol: %x\n", vol);

    return TRUE;
}


char
actSeqpSendMidi (void)
{
    MaybePRINTF("\tsend midi\n");
    return TRUE;
}


char
actSeqpSetLoop (void)
{
    MaybePRINTF("\tloop not tested!\n");
    return TRUE;
}


char
actSeqRTZ (void)
{
    ALUSMarker marker;
    alUSNewMarker (gSeq, &marker, 0);
    alUSSetLoc (gSeq, &marker);
    MaybePRINTF("\trtz\n");
    return TRUE;
}

char
actSeqEOS (void)
{
    ALUSMarker marker;
    alUSNewMarker (gSeq, &marker, 0x7fffffff);
    alUSSetLoc (gSeq, &marker);
    MaybePRINTF("\teos\n");
    return TRUE;
}


static u8 noteChan;
static u8 noteKey;

char
actSeqpSendNoteOn (void)
{
    u8 vel = GetRandomNumber (32, 127);
    noteChan = GetRandomNumber (1, 16);
    noteKey = GetRandomNumber (20, 80);
    
    alUSPSendMidi(gSeqp, 0, AL_MIDI_NoteOn | noteChan, noteKey, vel);

    return TRUE;
}


char
actSeqpSendNoteOff (void)
{
    alUSPSendMidi(gSeqp, 0, AL_MIDI_NoteOff | noteChan, noteKey, 0);
    return TRUE;
}



/*
 *
 * Random Number Helper Routines
 *
 */

int
GetRandomNumber (int min, int max) 
{
    float frand, fmin, fmax;
    static long seed = 1;

    seed = seed * 1103515245 + 12345;
    
    frand = (float)(seed & MAX_INT)/(float)MAX_INT; /* assume int = long */
    fmin = (float)min;
    fmax = (float)max;
    frand = frand * (max - min) + min;
    
    return (int)(frand + 0.5);
}


/*
  Initializes 'seq' with a random sequence.
  Assumes that gSeqFile and gSeqData have been fully initialized!
*/
void
__GetRandomSeq (ALUSeq **ppSeq)
{
    int	seqNum;
    s32 len;
    u8  *romData;
    
    seqNum = GetRandomNumber (0, gSeqFile->seqCount-1);

    romData = gSeqFile->seqArray[seqNum].offset;
    len = gSeqFile->seqArray[seqNum].len;

    if (len & 0x1)
	len++;

    if (len > MAX_SEQ_LENGTH)
	PRINTF("\tsequence %d too big!!!\n", seqNum);
    
    romCopy (romData, gSeqData, len);

    alUSNew (gSeq, gSeqData, len);

    *ppSeq = gSeq;
}


void
__GetRandomBank (ALBank **ppBank)
{
    int bankNum = GetRandomNumber (0, gBankFile->bankCount-1);

    *ppBank = gBankFile->bankArray[bankNum];
}


s32
__GetNumVoices (void)
{
    ALVoiceState        *vs;
    s32                 vCount = 0;
    
    for (vs = gSeqp->vAllocHead; vs != 0; vs = vs->next)
        vCount++;

    return vCount;  
}