/*************************************************************

  test_music.c : Nintendo 64 Music Tools Library Sample
  (c) Copyright 1998, Software Creations (Holdings) Ltd.

  Version 3.11

  NNSCHED demo main source file. This demo illustrates how to
  use a scheduler other than the default OS scheduler.

**************************************************************/

/* include system header files */

#include <ultra64.h>
#include <libmus.h>
#include <libmus_data.h>

#include "nnsched.h"
#include "dmacopy.h"
#include "debug.h"

/* internal function prototypes */
static void DmaRomToRam(void *rom, void *ram, int len);

/* music library callback function prototypes these prototypes must match the
   typedefs of the callback functions specified in "libmus.h":

      typedef void    (*LIBMUScb_install)     (void);
      typedef void    (*LIBMUScb_waitframe)   (void);
      typedef void    (*LIBMUScb_dotask)      (musTask *);
*/
static void NnSchedInstall(void);
static void NnSchedWaitFrame(void);
static void NnSchedDoTask(musTask *task);

/* music library scheduler callback structure */
static musSched nn_mus_sched = {
   NnSchedInstall, NnSchedWaitFrame, NnSchedDoTask
};

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
  [GLOBAL FUNCTION]
  InitMusicDriver()

  [Explantion]
  Download ROM files and initialise the music player.

  [Return value]
  NONE
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/

#define ALIGN_16(p) (((unsigned)(p) + 15) & ~15)

// シーケンス・ステータス構造体
typedef struct {
	u8       *seqBuf;
	int       seqBufSize;
	musHandle handle;
} MuSeqState;

typedef struct {
	musHandle handle;
} MuSndState;

// サウンド・ドライバー構造体
typedef struct {
	NNSched *nnSched;

	u8 *heap;
	int heapSize;

	u8 *pbkBuf;
	int pbkBufSize;

	MuSeqState *seqState;
	int         seqCount;

	u8 *fbkBuf;
	int fbkBufSize;

	MuSndState *sndState;
	int         sndCount;

	OSMesgQueue dmaMsgQ;
	OSMesg      dmaMsgBuf[8];

	NNScClient  nnClient;
	#define     QUEUE_SIZE 4

	OSMesgQueue nnFrameMsgQ;
	OSMesg      nnFrameMsgBuf[QUEUE_SIZE];

	OSMesgQueue nnTaskMsgQ;
	OSMesg      nnTaskMsgBuf[QUEUE_SIZE];
} MuDriver;

// サウンド・ドライバーです
MuDriver *muDriver;

// サウンド・ドライバーを初期化する
int muInitDriver(
	NNSched *sched,			// ＮＮスケジューラのアドレス
	void    *heap,			// オーディオヒープのアドレス
	int      heapSize,		// オーディオヒープのサイズ
	int      pbkBufSize,	// サンプルポインタバンクのサイズ
	int      seqBufSize,	// シーケンスバッファのサイズ
	int      seqBufCount,	// シーケンスバッファの数
	int      fbkBufSize,	// サウンドエフェクトバンクのサイズ
	int      sndBufCount,	// サウンドバッファの数
	int      audioPri		// オーディオスレッドのプライオリティ
	)
{
	MuDriver *st = muDriver = (MuDriver *)ALIGN_16(heap);
	musConfig init;
	int i;

	// ヒープメモリーアドレスを保存
	st->heap     = (u8 *)heap;
	st->heapSize = heapSize;
	heap = st + 1;

	// スケジューラアドレスを保存
	st->nnSched = sched;

	// サンプルポインタバンクを割り当てる
	st->pbkBuf     = (u8 *)ALIGN_16(heap);
	st->pbkBufSize = pbkBufSize;
	heap = st->pbkBuf + st->pbkBufSize;

	// シーケンスデータバッファを割り当てる
	st->seqState = (MuSeqState *)ALIGN_16(heap);
	st->seqCount = seqBufCount;
	heap = st->seqState + st->seqCount;

	for(i = 0; i < st->seqCount; i++) {
		st->seqState[i].seqBuf     = (u8 *)ALIGN_16(heap);
		st->seqState[i].seqBufSize = seqBufSize;
		st->seqState[i].handle     = 0;
		heap = st->seqState[i].seqBuf + seqBufSize;
	}

	// サウンドエフェクトバンクを割り当てる
	st->fbkBuf     = (u8 *)ALIGN_16(heap);
	st->fbkBufSize = pbkBufSize;
	heap = st->fbkBuf + st->fbkBufSize;

	// サウンドバッファを割り当てる
	st->sndState = (MuSndState *)ALIGN_16(heap);
	st->sndCount = sndBufCount;
	heap = st->sndState + st->sndCount;

	for(i = 0; i < st->sndCount; i++) {
		st->sndState[i].handle = 0;
	}

	// DMAデータ転送を行う為のメッセージＱを初期化
	osCreateMesgQueue(&st->dmaMsgQ, st->dmaMsgBuf,
		sizeof(st->dmaMsgBuf)/sizeof(st->dmaMsgBuf[0]));

	// Musに割り当てるヒープのアドレスとサイズを求める
	heap      = (void *)ALIGN_16(heap);
	heapSize -= (u32)heap - (u32)st->heap;
	DBG2(heapSize <= 0, "ヒープが足りません(%d/%d)\n", st->heapSize - heapSize, st->heapSize);

	// setup configuration structure
	init.control_flag       = 0;
	init.channels           = 24;
	init.sched              = sched;
	init.thread_priority    = audioPri;
	init.heap               = (u8 *)heap;
	init.heap_length        = heapSize;
	init.fifo_length        = 64;
	init.ptr                = NULL;
	init.wbk                = NULL;
	init.default_fxbank     = NULL;
	init.syn_output_rate    = 32000;
	init.syn_updates        = 256;
	init.syn_rsp_cmds       = 4096;
	init.syn_retraceCount   = 1;
	init.syn_num_dma_bufs   = 36;
	init.syn_dma_buf_size   = 0x1000;

	init.syn_updates        = 128;
	init.syn_rsp_cmds       = 2048;
	init.syn_num_dma_bufs   = 32;
	init.syn_dma_buf_size   = 640;

	// set for NN scheduler this function must be called before 'musInitialize'
	// otherwise default scheduler will be initialised and used
	MusSetScheduler(&nn_mus_sched);

	return MusInitialize(&init) + ((u8 *)heap - (u8 *)st->heap);
}

// サンプルポインタバンクを読み込む
int muSetPbkData(
	void *pbkRomAddr,	// サンプルポインタバンクのROMアドレス
	int   pbkSize,		// サンプルポインタバンクのサイズ
	void *wbkRomAddr	// サンプルウェーブバンクのROMアドレス
	)
// 戻値:
//   false: シーケンスを再生中であったため、データを読み込まなかった。
//   true : サンプルポインタバンクを読み込んだ。
{
	MuDriver *st = muDriver;

	DBG2(pbkSize > st->pbkBufSize,
		"サンプルポインタバンクバッファが足りません(%d/%d)\n",
		pbkSize, st->pbkBufSize);

	if(MusAsk(MUSFLAG_SONGS)) {
		return 0;
	}

	DmaRomToRam(pbkRomAddr, st->pbkBuf, pbkSize);
	MusPtrBankInitialize(st->pbkBuf, wbkRomAddr);

	return 1;
}

// シーケンスデータを読み込む
int muSeqSetData(
	int   seqBufNo,		// シーケンスバッファの番号
	void *seqRomAddr,	// シーケンスデータのＲＯＭアドレス
	int   seqSize		// シーケンスデータのサイズ
	)
// 戻値:
//   false: 指定したシーケンスバッファは、シーケンスを再生中であったため、データを読み込まなかった。
//   true : シーケンスデータを読み込んだ。
{
	MuDriver *st = muDriver;

	DBG1(seqBufNo < 0 || seqBufNo >= st->seqCount,
		"不正なシーケンスバッファ番号(%d)\n", seqBufNo);

	DBG2(seqSize > st->seqState[seqBufNo].seqBufSize,
		"シーケンスバッファが足りません(%d/%d)\n",
		seqSize, st->seqState[seqBufNo].seqBufSize);

	if(muSeqAsk(seqBufNo)) {
		return 0;
	}

	DmaRomToRam(seqRomAddr, st->seqState[seqBufNo].seqBuf, seqSize);

	return 1;
}

// シーケンスデータを再生する
void muSeqPlay(
	int seqBufNo		// シーケンスバッファの番号
	)
{
	MuDriver *st = muDriver;

	DBG1(seqBufNo < 0 || seqBufNo >= st->seqCount,
		"不正なシーケンスバッファ番号(%d)\n", seqBufNo);

	st->seqState[seqBufNo].handle = MusStartSong(st->seqState[seqBufNo].seqBuf);
}

// シーケンスハンドラを取得
musHandle muSeqGetHandle(
	int seqBufNo		// シーケンスバッファの番号
	)
// 戻値: シーケンスハンドラ
{
	MuDriver *st = muDriver;

	DBG1(seqBufNo < 0 || seqBufNo >= st->seqCount,
		"不正なシーケンスバッファ番号(%d)\n", seqBufNo);

	return st->seqState[seqBufNo].handle;
}

// いくつチャンネルが処理されているか調べる
int muSeqAsk(
	int seqBufNo		// シーケンスバッファの番号
	)
// 戻値: 処理されているチャンネル数
{
	MuDriver *st = muDriver;

	DBG1(seqBufNo < 0 || seqBufNo >= st->seqCount,
		"不正なシーケンスバッファ番号(%d)\n", seqBufNo);

	return MusHandleAsk(st->seqState[seqBufNo].handle);
}

// シーケンスの再生を停止する
int muSeqStop(
	int seqBufNo,		// シーケンスバッファの番号
	int speed			// 停止するまでのフレーム数
	)
// 戻値: コマンドが実行されたチャンネル数
{
	MuDriver *st = muDriver;

	DBG1(seqBufNo < 0 || seqBufNo >= st->seqCount,
		"不正なシーケンスバッファ番号(%d)\n", seqBufNo);

	return MusHandleStop(st->seqState[seqBufNo].handle, speed);
}

// シーケンスのボリュームを設定する
int muSeqSetVol(
	int seqBufNo,		// シーケンスバッファの番号
	int volume			// 設定するボリュームの値(0~256, 128で100%のボリューム)
	)
// 戻値: コマンドが実行されたチャンネル数
{
	MuDriver *st = muDriver;

	DBG1(seqBufNo < 0 || seqBufNo >= st->seqCount,
		"不正なシーケンスバッファ番号(%d)\n", seqBufNo);

	return MusHandleSetVolume(st->seqState[seqBufNo].handle, volume);
}

// シーケンスのパンを設定する
int muSeqSetPan(
	int seqBufNo,		// シーケンスバッファの番号
	int pan				// ステレオパンスケール値(0~256, 128でデフォルトの値)
	)
// 戻値: コマンドが実行されたチャンネル数
{
	MuDriver *st = muDriver;

	DBG1(seqBufNo < 0 || seqBufNo >= st->seqCount,
		"不正なシーケンスバッファ番号(%d)\n", seqBufNo);

	return MusHandleSetPan(st->seqState[seqBufNo].handle, pan);
}

// シーケンスのテンポを変更する
int muSeqSetTempo(
	int seqBufNo,		// シーケンスバッファの番号
	int tempo			// テンポ(0~256, 128でデフォルトの値)
	)
// 戻値: コマンドが実行されたチャンネル数
{
	MuDriver *st = muDriver;

	DBG1(seqBufNo < 0 || seqBufNo >= st->seqCount,
		"不正なシーケンスバッファ番号(%d)\n", seqBufNo);

	return MusHandleSetTempo(st->seqState[seqBufNo].handle, tempo);
}

// シーケンスの一時停止を行なう
int muSeqPause(
	int seqBufNo		// シーケンスバッファの番号
	)
// 戻値: もしコマンドが無視されれば0, そうでなければ0以外
{
	MuDriver *st = muDriver;

	DBG1(seqBufNo < 0 || seqBufNo >= st->seqCount,
		"不正なシーケンスバッファ番号(%d)\n", seqBufNo);

	return MusHandlePause(st->seqState[seqBufNo].handle);
}

// 一時停止したシーケンスを再開
int muSeqUnPause(
	int seqBufNo		// シーケンスバッファの番号
	)
// 戻値: もしコマンドが無視されれば0, そうでなければ0以外
{
	MuDriver *st = muDriver;

	DBG1(seqBufNo < 0 || seqBufNo >= st->seqCount,
		"不正なシーケンスバッファ番号(%d)\n", seqBufNo);

	return MusHandleUnPause(st->seqState[seqBufNo].handle);
}

// サウンドエフェクトバンクを読み込む
int muSetFbkData(
	void *fbkRomAddr,	// サウンドエフェクトバンクのROMアドレス
	int   fbkSize		// サウンドエフェクトバンクのサイズ
	)
// 戻値:
//   false: サウンドを再生中であったため、データを読み込まなかった。
//   true : サウンドエフェクトバンクを読み込んだ。
{
	MuDriver *st = muDriver;

	DBG2(fbkSize > st->fbkBufSize,
		"サウンドエフェクトバンクバッファが足りません(%d/%d)\n",
		fbkSize, st->fbkBufSize);

	if(MusAsk(MUSFLAG_EFFECTS)) {
		return 0;
	}

	DmaRomToRam(fbkRomAddr, st->fbkBuf, fbkSize);
	MusFxBankInitialize(st->fbkBuf);

	return 1;
}

// サウンドエフェクトバンクのアドレスを返す
void *muGetFbkAddr()
// 戻値:
//   サウンドエフェクトバンクのアドレス
{
	MuDriver *st = muDriver;

	return st->fbkBuf;
}

// サウンドデータを再生する
void muSndPlay(
	int sndBufNo,		// サウンドバッファの番号
	int number			// サウンドエフェクトの番号
	)
{
	MuDriver *st = muDriver;

	DBG1(sndBufNo < 0 || sndBufNo >= st->sndCount,
		"不正なサウンドバッファ(%d)\n", sndBufNo);

	st->sndState[sndBufNo].handle = MusStartEffect(number);
}

// サウンドデータを再生する2
void muSndPlay2(
	int sndBufNo,		// サウンドバッファの番号
	int number,			// サウンドエフェクトの番号
	int volume,			// ボリュームスケール
	int pan,			// パンスケール
	int overwrite,		// 同じ番号のオーバーライト（上書き用）サウンドエフェクト
	int priority		// プライオリティレベル
	)
{
	MuDriver *st = muDriver;

	DBG1(sndBufNo < 0 || sndBufNo >= st->sndCount,
		"不正なサウンドバッファ(%d)\n", sndBufNo);

	st->sndState[sndBufNo].handle = MusStartEffect2(
		number, volume, pan, overwrite, priority);
}

// サウンドハンドラを取得
musHandle muSndGetHandle(
	int sndBufNo		// サウンドバッファの番号
	)
// 戻値: サウンドハンドラ
{
	MuDriver *st = muDriver;

	DBG1(sndBufNo < 0 || sndBufNo >= st->sndCount,
		"不正なサウンドバッファ(%d)\n", sndBufNo);

	return st->sndState[sndBufNo].handle;
}

// いくつチャンネルが処理されているか調べる
extern int muSndAsk(
	int sndBufNo		// サウンドバッファの番号
	)
// 戻値: 処理されているチャンネル数
{
	MuDriver *st = muDriver;

	DBG1(sndBufNo < 0 || sndBufNo >= st->sndCount,
		"不正なサウンドバッファ(%d)\n", sndBufNo);

	return MusHandleAsk(st->sndState[sndBufNo].handle);
}

// サウンドの再生を停止する
int muSndStop(
	int sndBufNo,		// サウンドバッファの番号
	int speed			// 停止するまでのフレーム数
	)
// 戻値: コマンドが実行されたチャンネル数
{
	MuDriver *st = muDriver;

	DBG1(sndBufNo < 0 || sndBufNo >= st->sndCount,
		"不正なサウンドバッファ(%d)\n", sndBufNo);

	return MusHandleStop(st->sndState[sndBufNo].handle, speed);
}

// サウンドのボリュームを設定する
int muSndSetVol(
	int sndBufNo,		// サウンドバッファの番号
	int volume			// 設定するボリュームの値(0~256, 128で100%のボリューム)
	)
// 戻値: コマンドが実行されたチャンネル数
{
	MuDriver *st = muDriver;

	DBG1(sndBufNo < 0 || sndBufNo >= st->sndCount,
		"不正なサウンドバッファ番号(%d)\n", sndBufNo);

	return MusHandleSetVolume(st->sndState[sndBufNo].handle, volume);
}

// サウンドのパンを設定する
int muSndSetPan(
	int sndBufNo,		// サウンドバッファの番号
	int pan				// ステレオパンスケール値(0~256, 128でデフォルトの値)
	)
// 戻値: コマンドが実行されたチャンネル数
{
	MuDriver *st = muDriver;

	DBG1(sndBufNo < 0 || sndBufNo >= st->sndCount,
		"不正なサウンドバッファ番号(%d)\n", sndBufNo);

	return MusHandleSetPan(st->sndState[sndBufNo].handle, pan);
}

// サウンドの周波数を設定
int muSndSetFreq(
	int sndBufNo,		// サウンドバッファの番号
	float offset		// 周波数のオフセット
	)
// 戻値: 周波数オフセットが適応されたチャンネル数
{
	MuDriver *st = muDriver;

	DBG1(sndBufNo < 0 || sndBufNo >= st->sndCount,
		"不正なサウンドバッファ番号(%d)\n", sndBufNo);

	return MusHandleSetFreqOffset(st->sndState[sndBufNo].handle, offset);
}

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
  [INTERNAL FUNCTION]
  DmaRomToRam(rom, ram, len)

  [Parameters]
  rom          address of ROM source
  ram          address of RAM destination
  len          number of bytes to transfer

  [Explantion]
  Download an area of ROM to RAM. Note this function limits the size of any DMA
  generated to 16k so as to cause clashes with audio DMAs.

  [Return value]
  NONE
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/

/* avoid DMA clashes */
#define DMA_LEN 16384

static void DmaRomToRam(void *rom, void *ram, int len)
{
	MuDriver *st = muDriver;
	OSIoMesg io_mesg;
	OSMesg dummyMesg;
	int length;
	u32 src;
	unsigned char *dest;

	src = (u32)rom;
	dest = ram;

	while(len) {
		if(len > DMA_LEN)
			length = DMA_LEN;
		else
			length = len;

		osInvalDCache(dest, length);

		io_mesg.hdr.pri = OS_MESG_PRI_NORMAL;
		io_mesg.hdr.retQueue = &st->dmaMsgQ;
		io_mesg.dramAddr = dest;
		io_mesg.devAddr = src;
		io_mesg.size = length;

		osEPiStartDma(osCartRomHandle(), &io_mesg, OS_READ);

		src += length;
		dest += length;
		len -= length;

		osRecvMesg(&st->dmaMsgQ, &dummyMesg, OS_MESG_BLOCK);
	}
}

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
  [MUSIC LIBRARY CALLBACK FUNCTION]
  NnSchedInstall()

  [Explantion]
  Initialise the NN scheduler callback functions for the music library. This function
  is called once by the audio thread before entering an infinite loop.

  [Return value]
  NONE
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/

static void NnSchedInstall(void)
{
	MuDriver *st = muDriver;

	/* create message queues for WaitFrame and DoTask functions */
	osCreateMesgQueue(&st->nnFrameMsgQ, &st->nnFrameMsgBuf[0], QUEUE_SIZE);
	osCreateMesgQueue(&st->nnTaskMsgQ, &st->nnTaskMsgBuf[0], QUEUE_SIZE);

	/* add waitframe client */
	nnScAddClient(st->nnSched, &st->nnClient, &st->nnFrameMsgQ);
}

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
  [MUSIC LIBRARY CALLBACK FUNCTION]
  NnSchedWaitFrame()

  [Explantion]
  Wait for a retrace message for the music library. This function is called by the
  audio threads inifinite loop to wait for a retrace message. The 'syn_retraceCount'
  parameter of the musConfig structure must contain the number of retraces per
  message received.

  [Return value]
  NONE
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/

static void NnSchedWaitFrame(void)
{
	MuDriver *st = muDriver;
	NNScMsg *message;

	do {
		osRecvMesg(&st->nnFrameMsgQ, (OSMesg *)&message, OS_MESG_BLOCK);
		osRecvMesg(&st->nnFrameMsgQ, NULL, OS_MESG_NOBLOCK);  /* bin any missed syncs! */
	} while (*message != NN_SC_RETRACE_MSG);
}

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
  [MUSIC LIBRARY CALLBACK FUNCTION]
  NnSchedDoTask()

  [Parameters]
  task      address of the music library task descriptor structure

  [Explantion]
  Process a audio task for the music library. This function is called by the audio
  threads inifinite loop to generate an audio task and wait for its completion.

  The structure passed is defined in "libmus.h" and is defined as:

         typedef struct
         {
            u64   *data;
            int   data_size;
            u64   *ucode;
            u64   *ucode_data;
         } musTask;

  The 'data' and 'data_size' components of the structure relate to the command list
  to be processed. 'data' is the address of the command list and 'data_size' is the
  number of commands it contains.

  The 'ucode' and 'ucode_data' components of the structure relate to the microcode
  to be used. 'ucode' is the address of the microcode Text section, 'ucode_data' is
  the address of the microcode Data section.

  [Return value]
  NONE
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/

static void NnSchedDoTask(musTask *task)
{
	MuDriver *st = muDriver;
	NNScTask t;
	NNScMsg message;

	/* copy settings from musTask structure */
	t.list.t.data_ptr       = task->data;
	t.list.t.data_size      = task->data_size;
	t.list.t.ucode          = (u64 *) task->ucode;
	t.list.t.ucode_data     = (u64 *) task->ucode_data;

	/* fill in the rest of task data */
	t.next                      = 0;
	t.msgQ                      = &st->nnTaskMsgQ;
	t.msg                       = &message;
	t.list.t.type               = M_AUDTASK;
	t.list.t.ucode_boot         = (u64 *)rspbootTextStart;
	t.list.t.ucode_boot_size    = ((int) rspbootTextEnd - (int) rspbootTextStart);
	t.list.t.flags              = 0;
	t.list.t.ucode_size         = 4096;
	t.list.t.ucode_data_size    = SP_UCODE_DATA_SIZE;
	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;

	/* start task */
	osSendMesg(nnScGetAudioMQ(st->nnSched), (OSMesg) &t, OS_MESG_BLOCK);

	/* wait for task to finish */
	osRecvMesg(&st->nnTaskMsgQ, NULL, OS_MESG_BLOCK);
}

/* end of file */