/*
 *  NINTENDO64 SAMPLE PROGRAM
 *
 *  FILE : audio.c
 *
 *  Copyright (C) 1998, NINTENDO Co,Ltd.
 */


#include  <ultra64.h>
#include  "n_libaudio.h"
#include  "system.h"
#include  "mysched.h"
#include  "audio.h"


/*
 *  プロトタイプ宣言
 */
/* for audiomgr */
static  void   _amCreateAudioMgr(ALSynConfig *, OSPri);
static  void  __amMain          (void *);
static  void  __amHandleFrameMsg(s8);

/* for DMA */
static  s32        __amDMA        (s32, s32, void *);
static  ALDMAproc  __amDmaNew     (AMDMAState **);
static  void       __clearAudioDMA(void);

extern	OSPiHandle	*handler;

/*
 *  audio globals
 */
/* スケジューラ構造体 */
extern  MYSched  sc;

/* オーディオヒープ */
u8      audioHeap[AUDIO_HEAP_SIZE];
ALHeap  hp;

/* シーケンスバンクファイル */
ALSeqFile  *seqfile;

/* コンパクトシーケンスプレイヤー */
N_ALCSPlayer  *seqp;

/* コンパクトシーケンス */
ALCSeq  *seq;

/* サウンドプレイヤー */
N_ALSndPlayer  *sndp;

/* サウンドへのポインタ */
ALSndId  *sndid;

/* オーディオマネージャ */
AMAudioMgr  __am;
u64         audioStack[AUDIO_STACKSIZE / sizeof(u64)];

s8   min_only_one = 1;
u32  frameSize;
u32  minFrameSize;
u32  audFrameCt = 0;
u32  curAcmdList = 0;

/* DMA */
u32  nextDMA = 0;

AMDMAState   dmaState;
AMDMABuffer  dmaBuffs[NUM_DMA_BUFFERS];

OSMesgQueue  audDMAMessageQ;
OSMesg       audDMAMessageBuf[NUM_DMA_MESSAGES];
OSIoMesg     audDMAIOMesgBuf [NUM_DMA_MESSAGES];


/*
 *  オーディオの初期化
 */
void  initAudio(void) 
{
  s16            i;
  u32            length;
  ALBankFile    *midibankPtr;
  ALSynConfig    sync;
  ALSeqpConfig   seqc;
  ALSndpConfig   snpc;
  ALSound       *snd;


  /* オーディオヒープの初期化 */
  alHeapInit(&hp, audioHeap, AUDIO_HEAP_SIZE);    


  /* バンクファイル(.ctl)のロード */ 
  length      = _midibankSegmentRomEnd - _midibankSegmentRomStart;
  midibankPtr = alHeapAlloc(&hp, 1, length);
  romCopy(_midibankSegmentRomStart, (char *)midibankPtr, length);
    
  /* バンクファイルの初期化 */
  alBnkfNew(midibankPtr, (u8 *) _miditableSegmentRomStart);


  /* シーケンスバンクファイルのロード */
  length   = 4;
  seqfile  = alHeapAlloc(&hp, 1, length);
  romCopy(_seqSegmentRomStart, (char *)seqfile, length);

  length   = 4 + seqfile->seqCount * sizeof(ALSeqData);
  seqfile  = alHeapAlloc(&hp, 1, 4 + seqfile->seqCount * sizeof(ALSeqData));
  romCopy(_seqSegmentRomStart, (char *)seqfile, length);
  
  /* シーケンスバンクファイルの初期化 */
  alSeqFileNew(seqfile, (u8 *)_seqSegmentRomStart);


  /* シンセサイザの初期設定 */
  sync.outputRate = osAiSetFrequency(OUTPUT_RATE);
  sync.maxVVoices = MAX_VOICES;
  sync.maxPVoices = MAX_VOICES;
  sync.maxUpdates = MAX_UPDATES;
  sync.dmaproc    = &__amDmaNew;
  sync.heap       = &hp;
  sync.fxType     = AL_FX_NONE;
 

  /* オーディオマネージャの生成 */
  _amCreateAudioMgr(&sync, AUDIO_PRIORITY);
    

  /* シーケンスプレイヤーの初期設定 */
  seqc.maxVoices   = MAX_VOICES;
  seqc.maxEvents   = MAX_EVENTS;
  seqc.maxChannels = MAX_CHANNELS;
  seqc.heap        = &hp;

  /* ビブラート及びトレモロなし*/
  seqc.initOsc     = NULL;
  seqc.updateOsc   = NULL;
  seqc.stopOsc     = NULL;

  /* シーケンスプレイヤーの初期化 */
  seqp = alHeapAlloc(&hp, 1, sizeof(ALCSPlayer));
  n_alCSPNew(seqp, &seqc);


  /* プレイヤーに対する使用バンクの設定 */
  n_alCSPSetBank(seqp, midibankPtr->bankArray[0]);


  /* シーケンス構造体の用意 */
  seq = alHeapAlloc(&hp, 1, sizeof(ALCSeq));


  /* サウンドプレイヤーの初期設定 */
  snpc.maxSounds = MAX_VOICES;
  snpc.maxEvents = MAX_EVENTS;
  snpc.heap      = &hp;

  /* サウンドプレイヤーの初期化 */
  sndp = alHeapAlloc(&hp, 1, sizeof(ALSndPlayer));
  n_alSndpNew(sndp, &snpc);

  /* サウンドの割り当て

     使用サウンドエフェクト数  9
     移動時の効果音            126 (Applause)
     移動不可タイル選択時      127 (GunShot)  */

  /* 使用サウンドエフェクト数 */
  sndid = alHeapAlloc(&hp, 1, sizeof(ALSndId) * 9);

  /* 移動不可タイル選択時の効果音 */
  snd = midibankPtr->bankArray[0]->instArray[127]->soundArray[0];
  for(i = 0; i < 8; i++)
    sndid[i] = n_alSndpAllocate(snd);

  /* 移動時の効果音 */
  snd = midibankPtr->bankArray[0]->instArray[124]->soundArray[0];
  sndid[i] = n_alSndpAllocate(snd);
}


/*
 *  オーディオマネージャ作成
 */
static  void  _amCreateAudioMgr(ALSynConfig *c, OSPri pri)
{
  u32  i;
  f32  fsize;


  /* フレームサイズの設定 */
  fsize = (f32)NUM_FIELDS * c->outputRate / (f32) 60;
  frameSize = (s32) fsize;
  if (frameSize < fsize)
    frameSize++;
  frameSize = ((frameSize / SAMPLES) + 1) * SAMPLES;
  minFrameSize = frameSize - SAMPLES;

  /* シンセサイザの初期化 */
  n_alInit(&__am.g, c);


  /* DMA 関係の初期化 */
  dmaState.initialized = FALSE;

  dmaBuffs[0].node.prev = 0; 
  dmaBuffs[0].node.next = 0;
  for (i=0; i< NUM_DMA_BUFFERS - 1; i++){
    alLink((ALLink *)&dmaBuffs[i + 1], (ALLink *)&dmaBuffs[i]);
    dmaBuffs[i].ptr = alHeapAlloc(c->heap, 1, DMA_BUFFER_LENGTH);
  }
  dmaBuffs[i].ptr = alHeapAlloc(c->heap, 1, DMA_BUFFER_LENGTH);
    

  /* コマンドリストバッファの用意 */
  for(i=0; i < NUM_ACMD_LISTS; i++)
    __am.ACMDList[i] = (Acmd*)alHeapAlloc(c->heap, 1, MAX_RSP_CMDS * sizeof(Acmd));

  /* オーディオバッファの用意 */
  for (i = 0; i < NUM_OUTPUT_BUFFERS; i++) {
    __am.audioInfo[i] = (AudioInfo *)alHeapAlloc(c->heap, 1, sizeof(AudioInfo));
    __am.audioInfo[i]->data = alHeapAlloc(c->heap, 1, 4 * frameSize);
  }    
    

  /* リトレースメッセージキューの用意 */
  osCreateMesgQueue(&__am.audioFrameMsgQ, &__am.audioFrameMsgBuf, 1);

  /* Gfx CPU 処理終了メッセージキューの用意 */
  osCreateMesgQueue(&__am.audioStartMsgQ, &__am.audioStartMsgBuf, 1);

  /* オーディオ用 DMA メッセージキューの用意 */
  osCreateMesgQueue(&audDMAMessageQ, audDMAMessageBuf, NUM_DMA_MESSAGES);


  /* オーディオマネージャスレッド起動 */
  osCreateThread(&__am.thread, 5, __amMain, 0,
		 (void *)(audioStack + AUDIO_STACKSIZE / sizeof(u64)), pri);
  osStartThread(&__am.thread);
}


/*
 *  オーディオマネージャスレッド
 */
static  void  __amMain(void *arg) 
{

  MYScClient   client;
  MYScMsg     *msg = (MYScMsg *)0;
  s8           count = 2;


  /* スケジューラにクライアントとして登録 */
  myScAddClient(&sc, &client, &__am.audioFrameMsgQ);
    

  /* メインループ */
  while (1){

    /* スケジューラよりメッセージ取得 */
    (void) osRecvMesg(&__am.audioFrameMsgQ, (OSMesg *)&msg, OS_MESG_BLOCK);

    switch ((s32)(*msg)){

      /* リトレース */
      case (MY_SC_RETRACE_MSG):

#ifdef TIMER_BAR
	/* デバッグ用タイマーバー のカウンタ更新 */
	delta_gfx_rsp_start = time_gfx_rsp_start - time_retrace;
	delta_aud_rsp_start = time_aud_rsp_start - time_retrace;

	delta_gfx_cpu_start = time_gfx_cpu_start - time_retrace;
	delta_aud_cpu_start = time_aud_cpu_start - time_retrace;

	delta_gfx_rsp_end = time_gfx_rsp_end - time_retrace;
	delta_gfx_rdp_end = time_gfx_rdp_end - time_retrace;
	delta_aud_rsp_end = time_aud_rsp_end - time_retrace;

	delta_gfx_cpu_end = time_gfx_cpu_end - time_retrace;
	delta_aud_cpu_end = time_aud_cpu_end - time_retrace;

	time_retrace = osGetCount();

	delta_gfx_rsp_start *= TIME_SCALE;
	delta_aud_rsp_start *= TIME_SCALE;

	delta_gfx_cpu_start *= TIME_SCALE;
	delta_aud_cpu_start *= TIME_SCALE;

	delta_gfx_rsp_end *= TIME_SCALE;
	delta_gfx_rdp_end *= TIME_SCALE;
	delta_aud_rsp_end *= TIME_SCALE;

	delta_gfx_cpu_end *= TIME_SCALE;
	delta_aud_cpu_end *= TIME_SCALE;
#endif

	/* タスク作成 */
	__amHandleFrameMsg(count);
	if(count)
	  count--;
	break;
      
      /* NMI */
      case (MY_SC_PRE_NMI_MSG):
      default:
	break;
    }        
  }
  
  n_alClose(&__am.g);
}


/*
 *  タスク作成
 */
static  void  __amHandleFrameMsg(s8 count)
{

  s16         samplesLeft = 0;
  AudioInfo  *info;
  s16        *audioPtr;
  Acmd       *cmdp;
  s32         cmdLen;
  MYScTask   *t;
    

  /* カレントオーディオバッファ内の残存データ数を得る */
  samplesLeft = osAiGetLength() >> 2;

  /* カレントオーディオバッファのスワップ */
  if(!count)
    osAiSetNextBuffer(__am.audioInfo[(audFrameCt - 1) % 3]->data,
		      __am.audioInfo[(audFrameCt - 1) % 3]->frameSamples << 2);


  /* グラフィックス系スレッドにリトレースメッセージを送る */
  osSendMesg(&mainFrameMQ,        NULL, OS_MESG_BLOCK);
  osSendMesg(&sc.graphicsFrameMQ, NULL, OS_MESG_BLOCK);


  /* グラフィックスタスク作成処理の終了待ち */
  osRecvMesg(&__am.audioStartMsgQ, NULL, OS_MESG_BLOCK);

#ifdef TIMER_BAR
  time_aud_cpu_start = osGetCount();
#endif

  __clearAudioDMA();

  info     = __am.audioInfo[audFrameCt % 3];
  audioPtr = (s16 *)osVirtualToPhysical(info->data);
    

  /* フレームサイズの決定 */
  if((samplesLeft > (SAMPLES + EXTRA_SAMPLES)) & (min_only_one > 0)){             
    info->frameSamples = minFrameSize;
    min_only_one = -2;
  } else {
    info->frameSamples = frameSize;
    min_only_one ++;
  }


  /* CPU によるオーディオ処理 */
  cmdp = n_alAudioFrame(__am.ACMDList[curAcmdList], &cmdLen, audioPtr, info->frameSamples);


  /* タスク楮体設定 */
  t = &info->task;
    
  t->list.t.type             = M_AUDTASK;
  t->list.t.flags            = 0x0;
  t->list.t.ucode_boot       = (u64 *)rspbootTextStart;
  t->list.t.ucode_boot_size  = ((s32)rspbootTextEnd - (s32)rspbootTextStart);
  t->list.t.ucode            = (u64 *)n_aspMainTextStart;
  t->list.t.ucode_data       = (u64 *)n_aspMainDataStart;
  t->list.t.ucode_size       = SP_UCODE_SIZE;
  t->list.t.ucode_data_size  = SP_UCODE_DATA_SIZE;
  t->list.t.data_ptr         = (u64 *)__am.ACMDList[curAcmdList];
  t->list.t.data_size        = (cmdp - __am.ACMDList[curAcmdList]) * sizeof(Acmd);
  t->list.t.dram_stack       = (u64 *) NULL;
  t->list.t.dram_stack_size  = 0;
  t->list.t.output_buff      = (u64 *) NULL;
  t->list.t.output_buff_size = 0;
  t->list.t.yield_data_ptr   = NULL;
  t->list.t.yield_data_size  = 0;


  /* オーディオコマンドバッファのスワップ */
  curAcmdList ^= 1;

#ifdef TIMER_BAR
  time_aud_cpu_end = osGetCount();
#endif


  /* オーディオタスクスレッドにタスクを送る */
  osSendMesg(&sc.audioRequestMQ, (OSMesg)t, OS_MESG_BLOCK);
}


/*
 *  オーディオ用 DMA ルーチン
 */
static  s32 __amDMA(s32 addr, s32 len, void *state)
{
  void         *foundBuffer;
  s32           delta, addrEnd, buffEnd;
  AMDMABuffer  *dmaPtr, *lastDmaPtr;

  lastDmaPtr = 0;
  dmaPtr = dmaState.firstUsed;
  addrEnd = addr+len;
    
  while(dmaPtr){
    buffEnd = dmaPtr->startAddr + DMA_BUFFER_LENGTH;
    if(dmaPtr->startAddr > addr)
      break;
    else if(addrEnd <= buffEnd){
      dmaPtr->lastFrame = audFrameCt;
      foundBuffer = dmaPtr->ptr + addr - dmaPtr->startAddr;
      return (int) osVirtualToPhysical(foundBuffer);
    }
    lastDmaPtr = dmaPtr; 
    dmaPtr = (AMDMABuffer*)dmaPtr->node.next;
  }
  
  dmaPtr = dmaState.firstFree;

  if(!dmaPtr)
    return osVirtualToPhysical(dmaState.firstUsed);

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

  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 {
    dmaState.firstUsed = dmaPtr;
    dmaPtr->node.next = 0;
    dmaPtr->node.prev = 0;
  }
    
  foundBuffer = dmaPtr->ptr;
  delta = addr & 0x1;
  addr -= delta;
  dmaPtr->startAddr = addr;
  dmaPtr->lastFrame = audFrameCt;

  audDMAIOMesgBuf[nextDMA].hdr.pri      = OS_MESG_PRI_NORMAL;
  audDMAIOMesgBuf[nextDMA].hdr.retQueue = &audDMAMessageQ;
  audDMAIOMesgBuf[nextDMA].dramAddr     = foundBuffer;
  audDMAIOMesgBuf[nextDMA].devAddr      = (u32)addr;
  audDMAIOMesgBuf[nextDMA].size         = DMA_BUFFER_LENGTH;

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

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


static  ALDMAproc __amDmaNew(AMDMAState **state)
{
  if(!dmaState.initialized){
    dmaState.firstUsed = 0;
    dmaState.firstFree = &dmaBuffs[0];
    dmaState.initialized = 1;
  }
  
  *state = &dmaState;
  
  return __amDMA;
}


static void __clearAudioDMA(void)
{
  u32          i;
  OSIoMesg     *iomsg = (OSIoMesg *)0;
  AMDMABuffer  *dmaPtr,*nextPtr;
    
  for (i=0; i<nextDMA; i++)
    if (osRecvMesg(&audDMAMessageQ,(OSMesg *)&iomsg,OS_MESG_NOBLOCK) == -1)
      osSyncPrintf("Dma not done\n");
    
  dmaPtr = dmaState.firstUsed;
  while(dmaPtr){
    nextPtr = (AMDMABuffer*)dmaPtr->node.next;

    if(dmaPtr->lastFrame + FRAME_LAG < audFrameCt){
      if(dmaState.firstUsed == dmaPtr)
	dmaState.firstUsed = (AMDMABuffer*)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;
  }
    
  nextDMA = 0;
  audFrameCt++;
}