/*============================================================================

		NINTENDO64 TECHNICAL SUPPORT CENTER 
		
		    NINTENDO64 SAMPLE PROGRAM 2

		Copyright (C) 1997, NINTENDO Co,Ltd.

============================================================================*/
/*============================================================================
  audio.c

  Ver0.1  1996/11/15
          NTSCスケジューラ向けサンプル用に作成
  Ver0.1a 1996/11/19
          サウンドがぶちぶちとぎれるのを修正
          TYPE0 MIDI用にコンパイルするとエラーになるのを修正
  Ver0.2  1996/12/25
          auSeqPlayerState関数を追加
	  auSeqPlayerStop関数を追加
	  audioProc関数にPRE NMIメッセージ処理を追加
	  PRE NMIメッセージでフェードアウトするよう修正
          コメントをSJISに変更

  <!!!USE SJIS CODE!!!>

  このライブラリは任天堂テクニカルサポートセンターで開発した
  スケジューラ(NNスケジューラ)用につくられています。
  他のスケジューラを使用する場合はあちこち変更する必要があります。

  まだ最低限の関数しか実装してありません。他に必要な関数は各自
  作成してください。
  また、パラメータの調整が不十分ですので、使用する場合は、audio.hファイル
  を変更してパラメータの調整を行ってください。

  このソースは自由に使って頂いてかまいませんが、バグ情報等は
  なるべくフィードバックして頂くようよろしくお願いします。

（１）仕様
シーケンスプレイヤーは２つ作成されます。つまり２曲同時に再生できます。
ただし、最大発音数が設定値を越えると止まりますので注意してください。

（２）使用方法
   1.auAudioInit()をコールしてパラメータの初期化と、シンセサイザを起動する。
   2.auSeqplayerInit()をコールしてシーケンスプレイヤーに必要なデータを
     設定する。
     auSndPlayerInit()をコールしてサウンドプレイヤーに必要なデータを
     設定する。
   3.nnCreateScheduler()でスケジューラを起動したあとで、
     auCreateAudioThread()でオーディオスレッドを起動する。
   4.シーケンスを再生する場合は、
     auSeqPlayerSetFile()で再生させるシーケンスプレイヤーと
     再生するファイル番号と指定しシーケンスファイルを読み込む。
     auSeqPlayerPlay()で再生。
     サウンドを鳴らす場合は、
     auSndPlay(サウンド番号)で指定したサウンド番号の音が再生されます。
以上
============================================================================*/
#include <ultra64.h>
#include <PR/ramrom.h>
#include <assert.h>
#include "nnsched.h"
#include "audio.h"

extern OSPiHandle	*handler;

ALHeap audio_heap;                          /* audio heap structur */
u8     audio_heap_buf[AUDIO_HEAP_SIZE];     /* audio heap buffer  */
Acmd   *audio_cmdlist_ptr[2];                   /* cmd list    */
OSTask *audio_tlist_ptr[2];                     /* audio task list */
s16    *audio_buffer_ptr[3];                    /* audio output buffer */

ALBank *soundBank_ptr = NULL;
ALBankFile *midi_buffer_ptr = NULL;             /* seq midi bank data */
ALBankFile *snd_buffer_ptr = NULL;            /* sound bank data */
ALSeqFile  *seqHeaderfile_ptr = NULL;           /* seqence header file */
OSMesgQueue audioDmaMessageQ;
OSMesgQueue audioRomMessageQ;
OSMesg      audioDmaMessageBuf;
OSMesg      audioRomMessageBuf;
OSIoMesg    audioDmaIOMesgBuf[AUDIO_DMA_QUEUE_SIZE];
s32         nextDMA = 0;

static OSThread audioThread;
static u64      audioThreadStack[AUDIO_STACKSIZE/sizeof(u64)];

ALGlobals    audio_global;
ALSynConfig  audio_config;

/*-----sound player -----*/
ALSndPlayer   sndplayer;
ALSndpConfig  sndplayer_config;
ALInstrument* snd_inst;
ALBank        *snd_bank_ptr;
ALSndId       *snd_id;
u32           snd_alloc_num;

/* sequence playerのDMA callback ルーチンで使用する DMA buffer       */
typedef struct {
    ALLink      node;        /* リンクリストポインタ */
    int         startAddr;   /* データのROM内でのアドレス */
    u32         lastFrame;   /* 最後に使用したフレームカウンタの値 */
    char        *ptr;        /* バッファへのポインタ値 */
} DMABuffer;

/* sequence playerのDMA callback ルーチンで使用する DMA status        */
/* DMABufferの使用状態を格納する構造体                                */
typedef struct {
    u8          initialized;  /* すでに初期化されているかのフラグ    */
    DMABuffer   *firstUsed;   /* 使用中のDMABufferリンクリストの先頭 */
    DMABuffer   *firstFree;   /* 空きDMABufferリンクリストの先頭     */

} DMAState;

Audio_seqplayer seqplayer[2];
DMAState    dmaState;
DMABuffer   dmaBuffs[AUDIO_DMA_BUFFER_NUM];
u32         audio_framecnt = 0;
ALDMAproc dmaNew(DMAState **);


#ifdef  _AUDIO_DEBUG_DMA_
static u32 dma_frame_max = 0;   /* DMAコールバックの最大値 */
static u32 dma_call_cnt =0;     /* DMAコールバックの呼び出し回数 */
static u32 dma_use_cnt =0;      /* 実際にDMAを使った回数 */
#endif /* _AUDIO_DEBUG_DMA_


/*-----------------------------------------------------------------------------
  DMA転送(audio ライブラリで使用)
  u32   src_addr : 読み込み元カセットアドレス
  void* dest_addr: 出力先メモリアドレス
  u32   size     : 転送サイズ
-----------------------------------------------------------------------------*/
void auRomRead(u32 src_addr, void* dest_addr, u32 size)
{
  OSIoMesg    DmaIoMessageBuf;
  
  /* CPUキャッシュの無効化 */
  osInvalDCache((void*)dest_addr, (s32)size);

  /* start DMA read */

  DmaIoMessageBuf.hdr.pri      = OS_MESG_PRI_NORMAL;
  DmaIoMessageBuf.hdr.retQueue = &audioRomMessageQ;
  DmaIoMessageBuf.dramAddr     = dest_addr;
  DmaIoMessageBuf.devAddr      = src_addr;
  DmaIoMessageBuf.size         = size;

  osEPiStartDma(handler, &DmaIoMessageBuf, OS_READ);

  /* wait DMA read end */
  (void)osRecvMesg(&audioRomMessageQ, NULL, OS_MESG_BLOCK);

}


/*-----------------------------------------------------------------------------
  audioライブラリの初期化

  バッファの割り当てやaudioライブラリで使用するパラメータの初期化
  最初にここを呼ぶこと
-----------------------------------------------------------------------------*/
void auAudioInit(void)
{

  /*initialize audio heap */
  alHeapInit(&audio_heap, audio_heap_buf, AUDIO_HEAP_SIZE);
  
  /* create command list buffer */
  audio_cmdlist_ptr[0] = alHeapAlloc(&audio_heap, 1,
				     AUDIO_CLIST_SIZE_MAX*sizeof(Acmd));
  audio_cmdlist_ptr[1] = alHeapAlloc(&audio_heap, 1,
				     AUDIO_CLIST_SIZE_MAX*sizeof(Acmd));
  
  /* create task list buffer */
  audio_tlist_ptr[0] = alHeapAlloc(&audio_heap, 1, sizeof(OSTask));
  audio_tlist_ptr[1] = alHeapAlloc(&audio_heap, 1, sizeof(OSTask));

  /* create audio buffer */
  audio_buffer_ptr[0] = alHeapAlloc(&audio_heap, 1,
				    sizeof(s32)*AUDIO_BUFFER_MAX);
  audio_buffer_ptr[1] = alHeapAlloc(&audio_heap, 1,
				    sizeof(s32)*AUDIO_BUFFER_MAX);
  audio_buffer_ptr[2] = alHeapAlloc(&audio_heap, 1,
				    sizeof(s32)*AUDIO_BUFFER_MAX);


  /* create message queue for DMA */
  osCreateMesgQueue(&audioDmaMessageQ, &audioDmaMessageBuf, 1);
  osCreateMesgQueue(&audioRomMessageQ, &audioRomMessageBuf, 1);

  /* DMABuffer初期化フラグのクリアー */
  dmaState.initialized = 0;

  /* initialize audio library */
  audio_config.outputRate = osAiSetFrequency(AUDIO_OUTPUT_RATE);
  audio_config.maxVVoices = AUDIO_VVOICE_MAX;  /* 最大仮想ボイス数 */
  audio_config.maxPVoices = AUDIO_PVOICE_MAX;  /* 最大物理ボイス数 */
  audio_config.maxUpdates = AUDIO_UPDATE_MAX;  
  audio_config.dmaproc    = &dmaNew;            /* DMAコールバック関数 */
  audio_config.fxType     = AL_FX_SMALLROOM;    /* エフェクトタイプ */
  audio_config.heap       = &audio_heap;        /* audio heap */
  audio_config.params     = 0;                  /* カスタムエフェクト */
  alInit(&audio_global, &audio_config);
}



/*---------------------------------------------------------------

   DMA CallBack for sequence player 

   シーケンスプレーヤから呼び出されるDMAコールバックルーチン
   DMABufferに必要な値があれば、そのバッファの値を返し、
   なければ、DMAでデータをバッファに読み込む。
   この仕組みによりDMAコールの回数を減らすようにしている。
   ただし、使用されない部分は２フレームで消去される。
   この制御はCPUキャッシュのようにLIFOに変更したほうが
   効率がいいかも。
---------------------------------------------------------------*/
s32 dmaCallBack(s32 addr, s32 len, void *state)
{
  void        *freeBuffer;
  int         delta;
  DMABuffer   *dmaPtr,*lastDmaPtr;
  s32         addrEnd,buffEnd;


  lastDmaPtr = 0;
  dmaPtr = dmaState.firstUsed;
  addrEnd = addr+len;

#ifdef _AUDIO_DEBUG_DMA_
  dma_call_cnt++;
#endif /* _AUDIO_DEBUG_DMA_ */

  while(dmaPtr) {  /* バッファに欲しいデータがあるかチェック */

      buffEnd = dmaPtr->startAddr + AUDIO_DMA_BUFFER_SIZE;
      
      if(dmaPtr->startAddr > addr) {/* DMABufferはstartAddrが昇順に整列され
				       ているので、小さい値がきたら
				       バッファに欲しいデータはない */
	break;                   
      } else if(addrEnd <= buffEnd){  /* バッファにデータが存在する */
	dmaPtr->lastFrame = audio_framecnt; /* 現在のフレームカウンタの値をセット */
     
	/* 実際に必要なデータがあるアドレスの計算 */
	freeBuffer = dmaPtr->ptr + addr - dmaPtr->startAddr;

	/* バッファの物理アドレスを返す */
	return (int) osVirtualToPhysical(freeBuffer);
      }
      lastDmaPtr = dmaPtr;
      dmaPtr = (DMABuffer*)dmaPtr->node.next;
    }

  /*
     DMABufferに欲しいデータが含まれていなかったので、データをDMAで
     転送するよう設定する 
  */

  /* DMABufferのうち空きバッファを１つ取り出す */
  dmaPtr = dmaState.firstFree;

#ifdef _AUDIO_DEBUG
  assert(dmaPtr);  /* いちおうバッファが存在するかチェック */
#endif

  /* 空きバッファが無い場合にはNULLが取り出される     */
  /* ひとまず使用中のバッファの先頭のポインタを返す   */
  /* 止まるよりはましなので                           */
  if(dmaPtr == NULL){
    return(int)OS_K0_TO_PHYSICAL(dmaState.firstUsed->ptr);
  }

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

  /* 
     取得したDMABufferを使用中のリンクリストに
     startAddrが昇順になるように挿入する
  */
  if(lastDmaPtr) {

    /* 普通にリンクリストに挿入 */
      alLink((ALLink*)dmaPtr,(ALLink*)lastDmaPtr);

  } else if(dmaState.firstUsed) {

    /* リンクリストの先頭に挿入 */
    lastDmaPtr = dmaState.firstUsed;
    dmaState.firstUsed = dmaPtr;
    dmaPtr->node.next = (ALLink*)lastDmaPtr;
    dmaPtr->node.prev = 0;
    lastDmaPtr->node.prev = (ALLink*)dmaPtr;

  } else {

    /* 使用中のDMABufferが存在しない場合 */
    dmaState.firstUsed = dmaPtr;
    dmaPtr->node.next = 0;
    dmaPtr->node.prev = 0;
  
  }
  
  freeBuffer = dmaPtr->ptr;
  delta = addr & 0x1;
  addr -= delta;            /* DMA用にアドレス位置を２バイトに境界にする */
  dmaPtr->startAddr = addr;
  dmaPtr->lastFrame = audio_framecnt;  /* 現在のフレームカウンタをセット */

  /* DMA転送 */

  audioDmaIOMesgBuf[nextDMA].hdr.pri      = OS_MESG_PRI_NORMAL;
  audioDmaIOMesgBuf[nextDMA].hdr.retQueue = &audioDmaMessageQ;
  audioDmaIOMesgBuf[nextDMA].dramAddr     = freeBuffer;
  audioDmaIOMesgBuf[nextDMA].devAddr      = (u32)addr;
  audioDmaIOMesgBuf[nextDMA].size         = AUDIO_DMA_BUFFER_SIZE;

  osEPiStartDma(handler, &audioDmaIOMesgBuf[nextDMA++], OS_READ);

#ifdef _AUDIO_DEBUG_DMA_
  dma_use_cnt++;
#endif /* AUDIO_DEBUG_DMA_ */

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

/*-------------------------------------------------------------
 
  sequence player DMA callback set

  シーケンスプレイヤーに登録したとき初期用に１度呼び出される
  コールバックルーチン。次からはreturnで返したコールバックルーチン
  が呼び出される。
---------------------------------------------------------------*/
ALDMAproc dmaNew(DMAState **state)
{
  int         i;

  /* 初期化されているかチェック。初期化されいない場合は初期化する  */
  if(!dmaState.initialized) {
    
    dmaState.firstFree = &dmaBuffs[0];    /* 空きDMABufferリストの先頭を登録 */
    dmaState.firstUsed = NULL;            /* 使用中DMABufferなし */

    for (i = 0; i < AUDIO_DMA_BUFFER_NUM - 1; i++){
      alLink((ALLink*)&dmaBuffs[i+1],(ALLink*)&dmaBuffs[i]);
      dmaBuffs[i].ptr = alHeapAlloc(&audio_heap, 1, AUDIO_DMA_BUFFER_SIZE);
    }
    dmaBuffs[i].ptr = alHeapAlloc(&audio_heap, 1, AUDIO_DMA_BUFFER_SIZE);

    /* 初期化済みフラグセット */
    dmaState.initialized = 1;
  }
  *state = &dmaState;  /* state is never used in this case */


  return dmaCallBack;
}

/*-----------------------------------------------------------------

  DMA buffer cleanup

  DMABufferをサーチして2フレーム以上使われていない
  バッファを空きバッファのリンクリストに追加する。
-----------------------------------------------------------------*/
void auCleanDMABuffers(void)
{
  DMABuffer  *dmaPtr,*nextPtr;
  
  dmaPtr = dmaState.firstUsed;
  while(dmaPtr) {
    nextPtr = (DMABuffer*)dmaPtr->node.next;

    /*
       AUDIO_BUFFER_USE_FRAME数以上経過したバッファを
       空きバッファのリンクリストへ追加する。
       AUDIO_BUFFER_USE_FRAME数を増やすにはバッファを増やす
       必要があり、減らすとDMAの使用回数が増える
    */
    if(dmaPtr->lastFrame + AUDIO_BUFFER_USE_FRAME  < audio_framecnt){
      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;
  }
#ifdef _AUDIO_DEBUG_DMA_
 
  if(nextDMA >dma_frame_max){
    dma_frame_max = nextDMA;
  }

#endif /* _AUDIO_DEBUG_DMA_ */

  nextDMA=0;
  audio_framecnt++;  
}


/*------------------------------------------------------

  audio thread 

  スケジューラからのりとれーすメッセージで
  シンセサイズデータを計算しオーディオタスクを起動するよう
  スケジューラにメッセージを送る。
  auCreateAudioThread()で作成されるので、外部から
  起動する必要はない。

------------------------------------------------------*/
void audioProc(void* arg)
{
  OSMesgQueue  msgQ;
  OSMesg       msgbuf[AUDIO_MESGS_MAX];
  OSMesgQueue  rtn_msgQ;
  OSMesg       rtn_msgbuf[AUDIO_MESGS_MAX];
  NNScClient client;
  Acmd         *cmdlist_ptr;

  static s32   current_buffer = 0;
  static s32   current_audio_buffer = 1;
  static s16   audioSamples[3] = {0,0,0};
  static s32   cmdlist_len;

  s32          current_audio;
  s16*         audioOp;
  s32          frameSize;
  s32          minFrameSize;
  s32          samplesLeft = 0;  
  f32          fsize;
  OSMesgQueue  *sched_audioMQ;
  NNScTask   task[2];
  NNScTask   *au_task;
  short*       msg_type = NULL;
  u32          pre_nmi_flag =0;
  s16          get_seq_vol[2];
  s16          set_seq_vol[2];
  u32          cnt;

#ifdef _AUDIO_DEBUG_DMA_
  f32 hits;
#endif /* _AUDIO_DEBUG_DMA_ */

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

  /* create message queue for VI retrace */
  osCreateMesgQueue( &msgQ, msgbuf, AUDIO_MESGS_MAX);
  osCreateMesgQueue( &rtn_msgQ, rtn_msgbuf, AUDIO_MESGS_MAX);

  nnScAddClient((NNSched*)arg, &client, &msgQ);
  sched_audioMQ = nnScGetAudioMQ((NNSched*)arg);
  
  while(1){
    (void)osRecvMesg(&msgQ, (OSMesg*)&msg_type, OS_MESG_BLOCK);

    switch(*msg_type){
    case NN_SC_RETRACE_MSG:      /* りとれーすメッセージ処理 */ 
      
      /* PRE NMIが来ている場合はフェードアウトさせる*/
      switch(pre_nmi_flag){
      case 1: /* フェードアウト */
	for(cnt = 0;cnt < 2; cnt++){

	  /* 約0.5秒以内なのでちょと余裕をみて28frameで0にする */
	  set_seq_vol[cnt] -= get_seq_vol[cnt]/28;  
	  if(set_seq_vol[cnt] < 0){
	    set_seq_vol[cnt] = 0;
	  }
#ifdef _AUDIO_COMPACTMIDI_
	  alCSPSetVol(&seqplayer[cnt].seqplayer, set_seq_vol[cnt]);
#else
	  alSeqpSetVol(&seqplayer[cnt].seqplayer, set_seq_vol[cnt]);
#endif /* _AUDIO_COMPACTMIDI_ */
	}
	/*
	   フェードアウト処理終了チェック。終了したらタスクを止めるため
	   タスクを作成しない
	*/
	if((set_seq_vol[0] == 0) && (set_seq_vol[1] == 0)){
	  pre_nmi_flag++;
	}
	break;
      case 2:
	/* タスクを作成せずに終了 */
	continue;
	break;
      }
#ifdef _AUDIO_DEBUG_DMA_
      if(!(audio_framecnt % 60)){
	if(dma_call_cnt == 0 ){
	  hits =0;
	} else {
	  hits = (((f32)dma_call_cnt-(f32)dma_use_cnt)*100.0)/(f32)dma_call_cnt;
	}
	osSyncPrintf("dma max = %d /f, dma_call = %d, dma_use = %d, Hits = %f\n",dma_frame_max, dma_call_cnt, dma_use_cnt,hits);
	dma_call_cnt =0;
	dma_use_cnt =0;
      }
#endif /* _AUDIO_DEBGU_DMA_ */
      au_task = &task[current_buffer];
      cmdlist_ptr = audio_cmdlist_ptr[current_buffer];
      current_audio = current_audio_buffer % 3;

      auCleanDMABuffers();
      
      audioOp = (s16*) osVirtualToPhysical(audio_buffer_ptr[current_audio]);
      audioSamples[current_audio] = 16 + 
	(frameSize - samplesLeft + AUDIO_EXTRA_SAMPLES) & ~0x0f;
      if(audioSamples[current_audio] < minFrameSize)
	audioSamples[current_audio] = minFrameSize;
    
      cmdlist_ptr = alAudioFrame(cmdlist_ptr, &cmdlist_len, audioOp, audioSamples[current_audio]);
    

      au_task->next      = 0;                    /* paranoia */
      au_task->msgQ      = &rtn_msgQ;            /* reply to when finished */
      au_task->msg       = 0;                    /* reply with this message */
      
      au_task->list.t.data_ptr    = (u64 *)audio_cmdlist_ptr[current_buffer];
      au_task->list.t.data_size   = (cmdlist_ptr -audio_cmdlist_ptr[current_buffer])* sizeof(Acmd);
      au_task->list.t.type  = M_AUDTASK;
      au_task->list.t.ucode_boot = (u64 *)rspbootTextStart;
      au_task->list.t.ucode_boot_size =
	((int) rspbootTextEnd - (int) rspbootTextStart);
      au_task->list.t.ucode = (u64 *) aspMainTextStart;
      au_task->list.t.ucode_data = (u64 *) aspMainDataStart;
      au_task->list.t.ucode_data_size = SP_UCODE_DATA_SIZE;
      au_task->list.t.dram_stack = (u64 *) NULL;
      au_task->list.t.dram_stack_size = 0;
      au_task->list.t.output_buff = (u64 *) NULL;
      au_task->list.t.output_buff_size = 0;
      au_task->list.t.yield_data_ptr = NULL;
      au_task->list.t.yield_data_size = 0;
      
      osSendMesg(sched_audioMQ, (OSMesg*)au_task, OS_MESG_BLOCK);

      samplesLeft = osAiGetLength()>>2;
/*
      if(samplesLeft == 0 && !firsttime){
	osSyncPrintf("out of samples\n");
	firsttime = 0;
      }
*/
      current_buffer ^= 1;
      current_audio_buffer++;

      osRecvMesg(&rtn_msgQ, NULL, OS_MESG_BLOCK);
      osAiSetNextBuffer(audio_buffer_ptr[current_audio],
			audioSamples[current_audio]<<2);
      break;

    case NN_SC_PRE_NMI_MSG: /* PRE NMIメッセージ */
      /* 
	 !!重要!! NMI発生までにタスクを停止してください。
	 

	 ここにPRE NMIメッセージ処理を書いてください 
         このサンプルではシーケンスをフェードアウトさせていますが
	 サウンドについてはフェードさせていません。
      */
      pre_nmi_flag++;
#ifdef _AUDIO_COMPACTMIDI_
      get_seq_vol[0] = alCSPGetVol(&seqplayer[0].seqplayer);
      get_seq_vol[1] = alCSPGetVol(&seqplayer[1].seqplayer);
#else
      get_seq_vol[0] = alSeqpGetVol(&seqplayer[0].seqplayer);
      get_seq_vol[1] = alSeqpGetVol(&seqplayer[1].seqplayer);
#endif /* _AUDIO_COMPACTMIDI_ */
      set_seq_vol[0] = get_seq_vol[0];
      set_seq_vol[1] = get_seq_vol[1];
      break;
    }
  }
  
}



/*--------------------------

  read sequence file header

---------------------------*/
void auReadSeqFileHeader(u32 src_addr)
{
  s32       seqfile_size;

  seqHeaderfile_ptr = alHeapAlloc(&audio_heap, 1, 4);
  /* read sequence file header length */ 
  auRomRead(src_addr, seqHeaderfile_ptr, 4);

  seqfile_size = 4 + seqHeaderfile_ptr->seqCount * sizeof(ALSeqData);
  seqHeaderfile_ptr = alHeapAlloc(&audio_heap, 1, seqfile_size);

  /* read sequence file header */
  auRomRead(src_addr, seqHeaderfile_ptr, seqfile_size);
}


/*----------------------------------------------------
  audio thread create and start
  オーディオスレッドの作成と起動
----------------------------------------------------*/
void auCreateAudioThread(NNSched *sched)
{

  osCreateThread(&audioThread, AUDIO_THREAD_ID, audioProc, (void *)sched,
		 (audioThreadStack+AUDIO_STACKSIZE/sizeof(u64)),
		  AUDIO_THREAD_PRI);
  osStartThread(&audioThread);

}

/*-----------------------------------------------------------------------------

  sequence player initialize

  シーケンスプレイヤーの初期化
input
  midi_start: バンクファイル(.ctl)先頭ROMアドレス
  midi_end: バンクファイル(.ctl)終了ROMアドレス
  seqheader_start:シーケンスファイル(.sbk)先頭ROMアドレス
  seqheader_end:シーケンスファイル(.sbk)終了ROMアドレス
  midi_table_star:ウェーブテーブルファイル(.tbl)先頭ROMアドレス
-----------------------------------------------------------------------------*/
void auSeqPlayerInit(u8* midi_start, u8* midi_end,
		     u8* seqheader_start, u8* seqheader_end,
		     u8* midi_table_start) 
{
  ALBank *midiBank_ptr;
  u32    size;
  /* create sequence data buffer */
  seqplayer[0].seqdata_ptr = alHeapAlloc(&audio_heap, 1, AUDIO_SEQDATA_SIZE_MAX);
  seqplayer[1].seqdata_ptr = alHeapAlloc(&audio_heap, 1, AUDIO_SEQDATA_SIZE_MAX);

  /* initialize sequence player 0 */
  seqplayer[0].seqconfig.maxVoices   = AUDIO_SEQ_VVOICE_MAX;/* 最大仮想ボイス数 */
  seqplayer[0].seqconfig.maxEvents   = AUDIO_SEQ_EVTCOUNT_MAX;  /* 最大内部イベント数 */
  seqplayer[0].seqconfig.maxChannels = AUDIO_SEQ_CHANNEL_MAX;/* 最大MIDIチャンネル数 */
  seqplayer[0].seqconfig.heap        = &audio_heap;      /* audio heap */
  seqplayer[0].seqconfig.initOsc     = 0;
  seqplayer[0].seqconfig.updateOsc   = 0;
  seqplayer[0].seqconfig.stopOsc     = 0;
  seqplayer[0].seqconfig.debugFlags  = 0;

#ifdef _AUDIO_COMPACTMIDI_
  alCSPNew(&seqplayer[0].seqplayer, &seqplayer[0].seqconfig);
#else
  alSeqpNew(&seqplayer[0].seqplayer, &seqplayer[0].seqconfig);
#endif /* _AUDIO_COMPACTMIDI_ */

  /* initialize sequence player 1 */
  seqplayer[1].seqconfig.maxVoices   = AUDIO_SEQ_VVOICE_MAX;/* 最大仮想ボイス数 */
  seqplayer[1].seqconfig.maxEvents   = AUDIO_SEQ_EVTCOUNT_MAX;  /* 最大内部イベント数 */
  seqplayer[1].seqconfig.maxChannels = AUDIO_SEQ_CHANNEL_MAX;/* 最大MIDIチャンネル数 */
  seqplayer[1].seqconfig.heap        = &audio_heap;      /* audio heap */
  seqplayer[1].seqconfig.initOsc     = 0;
  seqplayer[1].seqconfig.updateOsc   = 0;
  seqplayer[1].seqconfig.stopOsc     = 0;
  seqplayer[1].seqconfig.debugFlags  = 0;

#ifdef _AUDIO_COMPACTMIDI_
  alCSPNew(&seqplayer[1].seqplayer, &seqplayer[1].seqconfig);
#else
  alSeqpNew(&seqplayer[1].seqplayer, &seqplayer[1].seqconfig);
#endif /* _AUDIO_COMPACTMIDI_ */

  /* read seqfileheader data */
  auReadSeqFileHeader((u32)seqheader_start);
  alSeqFileNew(seqHeaderfile_ptr, seqheader_start);

  /* read midi bank data */
  size = (u32)midi_end-(u32)midi_start;
  midi_buffer_ptr = alHeapAlloc(&audio_heap, 1, size);
  auRomRead((u32)midi_start, midi_buffer_ptr, size);

  /* シーケンサが使うインスゥルメントバンク指定 */
  alBnkfNew(midi_buffer_ptr, midi_table_start);
  midiBank_ptr = midi_buffer_ptr->bankArray[0];

#ifdef _AUDIO_COMPACTMIDI_
  alCSPSetBank(&seqplayer[0].seqplayer, midiBank_ptr);
  alCSPSetBank(&seqplayer[1].seqplayer, midiBank_ptr);
#else
  alSeqpSetBank(&seqplayer[0].seqplayer, midiBank_ptr);
  alSeqpSetBank(&seqplayer[1].seqplayer, midiBank_ptr);
#endif /* _AUDIO_COMPACTMIDI_ */

}


/*-----------------------------------------------------------------------------
  sequence player seqno setup

  シーケンスデータの読み込み

 u32 seqplayer: シーケンスプレイヤー番号
 s32 seqno    : シーケンス番号
-----------------------------------------------------------------------------*/
void auSeqPlayerSetFile(u32 seqplayer_no, s32 seqno)
{
  s32 seqdata_len;
  u8*  seqdata_offset;

#ifdef _AUDIO_DEBUG_
  if(seqHeaderfile_ptr->seqCount < seqno){
    osSyncPrintf("seqence no is over!!(seqcount = %d)\n",
		 seqHeaderfile_ptr->seqCount);
    return;
  }
#endif /* _AUDIO_DEBUG_ */

  seqdata_offset = seqHeaderfile_ptr->seqArray[seqno].offset;
  seqdata_len = seqHeaderfile_ptr->seqArray[seqno].len;
  if(seqdata_len & 0x01) seqdata_len++;

  /* シーケンスデータの読み込み */
  auRomRead((u32)seqdata_offset, seqplayer[seqplayer_no].seqdata_ptr, seqdata_len);

  seqplayer[seqplayer_no].seqno = seqno;

}

/*----------------------------------------------------------------------------
  play sequence

Input:
  seqplayer_no: 再生を開始するシーケンスプレイヤー番号

  シーケンスプレイヤーがAL_STOPPEDの状態でない場合は
  FALSEを返す。
----------------------------------------------------------------------------*/
int auSeqPlayerPlay(u32 seqplayer_no)
{
#ifndef _AUDIO_COMPACTMIDI_
  s32 seqdata_len;
  u32 seqno;
#endif /* _AUDIO_COMPACTMIDI_ */

#ifdef _AUDIO_DEBUG_
  if(seqplayer_no > 1){
    osSyncPrintf("seqplayer_no over!!\n");
    return FALSE;
  }
#endif /* _AUDIO_DEBUG_ */

  /* check seqplayer state. */
  if(seqplayer[seqplayer_no].seqplayer.state != AL_STOPPED){
#ifdef _AUDIO_DEBUG_
    osSyncPrintf("sequence player %d is playing\n",seqplayer_no);
#endif /* _AUDIO_DEBU_ */

    return FALSE;
  }

#ifdef _AUDIO_COMPACTMIDI_
  alCSeqNew(&seqplayer[seqplayer_no].sequence, seqplayer[seqplayer_no].seqdata_ptr);
  alCSPSetSeq(&seqplayer[seqplayer_no].seqplayer, &seqplayer[seqplayer_no].sequence);
  alCSPPlay(&seqplayer[seqplayer_no].seqplayer);
#else
  seqno = seqplayer[seqplayer_no].seqno;
  seqdata_len = seqHeaderfile_ptr->seqArray[seqno].len;
  alSeqNew(&seqplayer[seqplayer_no].sequence, seqplayer[seqplayer_no].seqdata_ptr, seqdata_len);
  alSeqpSetSeq(&seqplayer[seqplayer_no].seqplayer, &seqplayer[seqplayer_no].sequence);
  alSeqpPlay(&seqplayer[seqplayer_no].seqplayer);
#endif /* _AUDIO_COMPACTMIDI_ */
  return TRUE;
}

/*----------------------------------------------------------------------------
   sequence stop

Input:
  seqplayer_no: 停止するシーケンスプレイヤー番号
----------------------------------------------------------------------------*/
void auSeqPlayerStop(u32 seqplayer_no)
{
#ifdef _AUDIO_COMPACTMIDI_
  alCSPStop(&seqplayer[seqplayer_no].seqplayer);
#else 
  alSeqpStop(&seqplayer[seqplayer_no].seqplayer);
#endif /* _AUDIO_COMPACTMIDI_ */
}



/*----------------------------------------------------------------------------
  sequence state

Input:
  seqplayer_no: 状態を取得するシーケンスプレイヤーの番号

  シーケンスプレイヤーの状態を返す。
----------------------------------------------------------------------------*/
s32 auSeqPlayerState(u32 seqplayer_no)
{
#ifdef _AUDIO_COMPACTMIDI_
  /* manにはないが、libaudio.hにはあるので使っています。 */
  return alCSPGetState(&seqplayer[seqplayer_no].seqplayer);
#else 
/*  return alSeqpGetState(&seqplayer[seqplayer_no].seqplayer);*/
  return seqplayer[seqplayer_no].seqplayer.state;

#endif /* _AUDIO_COMPACTMIDI_ */
}

/*-----------------------------------------------------------------------------
  サウンドプレイヤーの初期化

Input
  sndbankstart_ptr: サウンドのバンクファイル(.ctl)先頭ROMアドレス
  sndbankend_ptr:   サウンドのバンクファイル(.ctl)終了ROMアドレス
  sndtablestart_ptr:ウェーブテーブルファイル(.tbl)先頭ROMアドレス
-----------------------------------------------------------------------------*/
void auSndPlayerInit(u8* sndbankstart_ptr, u8* sndbankend_ptr,
		     u8* sndtablestart_ptr)
{
  u32 size;
  u32 cnt;

  /* read sound bank(.ctl file) */
  size = (u32)sndbankend_ptr-(u32)sndbankstart_ptr;
  snd_buffer_ptr = alHeapAlloc(&audio_heap, 1, size);
  auRomRead((u32)sndbankstart_ptr, snd_buffer_ptr, size);

  /* soundplayer initialize */
  sndplayer_config.maxSounds   = AUDIO_SND_VOICE_MAX;
  sndplayer_config.maxEvents   = AUDIO_SND_EVTCOUNT_MAX;
  sndplayer_config.heap        = &audio_heap;
  alSndpNew(&sndplayer, &sndplayer_config);

  /* bankfile initialize */
  alBnkfNew(snd_buffer_ptr, sndtablestart_ptr);

  /*
     バンクファイルに登録されている順にサウンドデータを
     サウンドプレイヤーに登録
  */
  snd_bank_ptr = snd_buffer_ptr->bankArray[0];
  snd_inst = snd_bank_ptr->instArray[0];
  snd_id = alHeapAlloc(&audio_heap, 1, snd_inst->soundCount*sizeof(ALSndId));

  for(cnt = 0, snd_alloc_num =0; cnt < snd_inst->soundCount; cnt++){
    snd_id[cnt] = alSndpAllocate(&sndplayer, snd_inst->soundArray[cnt]);
    if(snd_id[cnt] != -1) {
      snd_alloc_num++;
    }
  }
}

/*-----------------------------------------------------------------------------
  サウンドの再生
Input
  sndno: 再生するサウンドの番号
-----------------------------------------------------------------------------*/
void auSndPlay(u32 sndno)
{
  s32 status;

  alSndpSetSound(&sndplayer, snd_id[sndno]);
  status = alSndpGetState(&sndplayer);
  if(status == AL_STOPPED){
    alSndpPlay(&sndplayer);
  }

}

/*-----------------------------------------------------------------------------
  サウンドの停止
Input
  sndno:停止するサウンドの番号
-----------------------------------------------------------------------------*/
void auSndStop(u32 sndno)
{
  alSndpSetSound(&sndplayer,snd_id[sndno]);
  alSndpStop(&sndplayer);
}

/*-----------------------------------------------------------------------------
  サウンドの状態の取得
Input
  sndno:状態を取得したいサウンドの番号
Return:
  sndnoで指定したサウンドの状態
-----------------------------------------------------------------------------*/
s32 auSndGetState(u32 sndno)
{
  alSndpSetSound(&sndplayer, snd_id[sndno]);
  return alSndpGetState(&sndplayer);
}