maphrcnv.c

是一个手机功能的模拟程序

		dVocSize	-= 9L;
		pbVoc		+= 10;

		/*	Check format and drumkey	*/
		if(	((pbVoc[0] & 0x04) || (pbVoc[1] & 0x03)) ||
			((dDrumKey < 1L) || (48000 < dDrumKey))) {
			MAPHRCNV_DBGMSG(("Invalid format[%02X-%02X] or drum key[%08lX] \n",
				((pbVoc[0] >> 2) & 0x01), (pbVoc[1] & 0x03), dDrumKey));
			return (0L);
		}
	}
	else {
		return (MASMW_SUCCESS);
	}

	/*	Check BankNo and ProgNo range	*/
	if(	((dBankNo != 0x01L) && (dBankNo != 0x81L))	||
		((dBankNo == 0x01L) && (dProgNo > 127L))	||
		((dBankNo == 0x81L) && ((dProgNo < 1L) || (47L < dProgNo)))) {

		MAPHRCNV_DBGMSG(("Invalid BankNo[%02X] or ProgNo[%02X] \n",
			 dBankNo, dProgNo));
		return (0L);
	}

	pVi = GetVoiceInfo(dBankNo, dProgNo, &(pDi->sVocInfo[0]));
	if(pVi != NULL) {
		MAPHRCNV_DBGMSG(("Already add voice BankNo[%02X] or ProgNo[%02X] \n",
			 dBankNo, dProgNo));
		return (0L);
	}

	machdep_memcpy(&(bParam[0]), &(pbVoc[0]), dVocSize);

	/*	set wave data	*/
	if(dSynth == 2L) {
		if(dWaveId & 0x80L) {	/*	ROM data	*/
			sdWaveAdr = MaResMgr_GetDefWaveAddress((UINT32)(dWaveId & 0x3FL));
		}
		else {					/*	RAM data	*/
			sdWaveAdr = SetWaveData(dPhrCh, dWaveId, pWtBank);
			if(sdWaveAdr < 0L) return (sdWaveAdr);
		}

		if(sdWaveAdr <= 0L) {
			MAPHRCNV_DBGMSG(("Invalid wave data[%02X] \n", dWaveId));
			return (0L);
		}

		bParam[7] = (UINT8)(((UINT32)sdWaveAdr >> 8) & 0xFF);
		bParam[8] = (UINT8)((UINT32)sdWaveAdr & 0xFF);
	}

	/*	check ram address	*/
	if((pAi->dRamAdr + dVocSize) > pAi->dRamEndAdr) {
		MAPHRCNV_DBGMSG(("RAM Over!! [%08lX %08lX]\n", pAi->dRamAdr, dVocSize));
		return (0L);
	}

	/*	extend voice setting	*/
	sdRet = MaDevDrv_SendDirectRamData(pAi->dRamAdr, 0, &(bParam[0]), dVocSize);
	if(sdRet < MASMW_SUCCESS) {
		MAPHRCNV_DBGMSG(("MaDevDrv_SendDirectRanData[Return:%ld] \n", sdRet));
		return (sdRet);
	}

	/*	add voice infomation	*/
	for(i = 0; i < MAPHR_MAX_LV2_VOICES; i++) {
		pVi = &(pDi->sVocInfo[i]);
		if(pVi->dBankNo == 0xFFFFFFFF) {
			pVi->dBankNo = dBankNo;
			pVi->dProgNo = dProgNo;
			break;
		}
	}
	MASMW_ASSERT(i < MAPHR_MAX_LV2_VOICES);

	/*	Remove voice	*/
	dBankNo	= (UINT32)(dBankNo + dPhrCh);
	MaSndDrv_SetVoice(	gPhrInfo.sdSeqId,
						dBankNo,			/*	Bank Number				 */
						dProgNo,			/*	Program Number			 */
						dSynth,				/*	Synth Mode				 */
						dDrumKey,			/*	Durum Key				 */
						0xFFFFFFFF);		/*	Registered voice address */
	/*	Set voice	*/
	MaSndDrv_SetVoice(	gPhrInfo.sdSeqId,
						dBankNo,			/*	Bank Number				 */
						dProgNo,			/*	Program Number			 */
						dSynth,				/*	Synth Mode				 */
						dDrumKey,			/*	Durum Key				 */
						pAi->dRamAdr);		/*	Registered voice address */

	MAPHRCNV_DBGMSG(("Register Voice[BK:%02X PG:%02X KEY:%08lX RAM:%08lX]\n",
								 dBankNo, dProgNo, dDrumKey, pAi->dRamAdr));

	/*	update ram address	*/
	pAi->dRamAdr += dVocSize;
	if(pAi->dRamAdr & 0x00000001) pAi->dRamAdr++;
	return (1L);
}

/****************************************************************************
 *	SetupVoice2
 *
 *	Function:
 *			register voices for LV2.
 *	Argument:
 *			dPhrCh	Sequence Number(0..3)
 *	Return:
 *			0	success.
 *			< 0	error code.
 *
 ****************************************************************************/
static SINT32	SetupVoice2(UINT32 dPhrCh)
{
	UINT8*				pbVoc;
	UINT32				dIdx;
	UINT32				dSize;
	UINT32				dChunkId;
	UINT32				dChunkSize;
	SINT32				sdRet;
	PMAPHRAPIINFO		pAi;
	PMALIBPHRINFO		pDi;
	static MAPHRWTBANK	sWtBank[MAPHR_MAX_WAVES];

	pAi = &(gPhrInfo.sApiInfo[dPhrCh]);
	pDi = &(pAi->sDataInfo);

	/*	no voice	*/
	if(pDi->pbVoice == NULL) {
		return (MASMW_SUCCESS);
	}

	/*	calucurate ram address	*/
	dSize			= (UINT32)(gPhrInfo.dRamSize >> 2);
	pAi->dRamAdr	= (UINT32)(gPhrInfo.dRamAdr + (dSize * dPhrCh));
	pAi->dRamEndAdr	= (UINT32)(pAi->dRamAdr + dSize);

	MAPHRCNV_DBGMSG(("SetupVoice2 [%X %08lX-%08lX]\n",
									dPhrCh, pAi->dRamAdr, pAi->dRamEndAdr));

	/*	initialize WT bank	*/
	for(dIdx = 0; dIdx < MAPHR_MAX_WAVES; dIdx++) {
		sWtBank[dIdx].pbWave	= NULL;
		sWtBank[dIdx].dSize		= 0L;
		sWtBank[dIdx].dRamAdr	= 0L;
	}

	dIdx	= 0L;
	pbVoc	= pDi->pbVoice;
	dSize	= pDi->dVoiceSize;
	while(	(dSize >= (UINT32)(MAPHR_SIZE_OF_CHUNKHEADER)) &&
			(dIdx < MAPHR_MAX_LV2_VOICES)) {

		dChunkId	= MAPHR_MAKEDWORD(pbVoc[0], pbVoc[1], pbVoc[2], pbVoc[3]);
		dChunkSize	= MAPHR_MAKEDWORD(pbVoc[4], pbVoc[5], pbVoc[6], pbVoc[7]);
		pbVoc		+= (UINT32)MAPHR_SIZE_OF_CHUNKHEADER;

		/*	Check chunk size	*/
#if 0
		if(dSize < (UINT32)(MAPHR_SIZE_OF_CHUNKHEADER + dChunkSize)) {
			return (MASMW_ERROR_CHUNK_SIZE);
		}
#endif

		/*	extend wt data chunk	*/
		if(dChunkId == MAPHR_MAKEDWORD('E', 'X', 'W', 'V')) {
			SetWtBank(pbVoc, dChunkSize, &(sWtBank[0]));
		}
		/*	extend voice chunk	*/
		else if(dChunkId == MAPHR_MAKEDWORD('E', 'X', 'V', 'O')) {
			sdRet = SetVoice2(dPhrCh, pbVoc, dChunkSize, &(sWtBank[0]));
			if(sdRet < MASMW_SUCCESS) return (sdRet);
			if(sdRet > 0L) dIdx++;	/*	update number of voice	*/
		}

		/*	Update	*/
		pbVoc	+= dChunkSize;
		dSize	-= (UINT32)(dChunkSize + MAPHR_SIZE_OF_CHUNKHEADER);
	}

	return (MASMW_SUCCESS);
}


/****************************************************************************
 *	RemoveVoices
 *
 *	Function:
 *			remove voices.
 *	Argument:
 *			dPhrCh	Sequence Number(0..3)
 *	Return:
 *			0	success.
 *			< 0	error code.
 *
 ****************************************************************************/
static SINT32	RemoveVoices(UINT32 dPhrCh)
{
	UINT32			i;
	UINT32			dVoices;
	PMAPHRAPIINFO	pAi;
	PMALIBVOCINFO	pVi;

	pAi = &(gPhrInfo.sApiInfo[dPhrCh]);
	pVi = &(pAi->sDataInfo.sVocInfo[0]);

	if(pAi->sDataInfo.dVersion == (UINT32)MAPHR_VERSION_LV2)
		dVoices	= MAPHR_MAX_LV2_VOICES;
	else
		dVoices	= MAPHR_MAX_LV1_VOICES;

	for(i = 0; i < dVoices; i++) {
		if((pVi[i].dBankNo == 0x01L) || (pVi[i].dBankNo == 0x81L)) {
			/*	Remove voice	*/
			MaSndDrv_SetVoice(	gPhrInfo.sdSeqId,
								pVi[i].dBankNo + dPhrCh,	/*	Bank Number		*/
								pVi[i].dProgNo,				/*	Program Number	*/
								1L,							/*	Synth Mode		*/
								0L,							/*	Durum Key		*/
								0xFFFFFFFF);

			MAPHRCNV_DBGMSG(("Remove Voice[BK:%02X PG:%02X]\n",
										 pVi[i].dBankNo, pVi[i].dProgNo));
		}
	}

	return (MASMW_SUCCESS);
}

/****************************************************************************
 *	PhrAudCnv_Initialize
 *
 *	Function:
 *			Initialize SMAF/Phrase and SMAF/Audio converter.
 *	Argument:
 *
 *	Return:
 *			0	success.
 *
 ****************************************************************************/
SINT32	PhrAudCnv_Initialize(void)
{
	MAPHRCNV_DBGMSG(("PhrAudCnv_Initialize\n"));

	gPhrInfo.sdSeqId		= -1L;
	gPhrInfo.dCreateStatus	= 0x00000000;
	gPhrInfo.dPlayStatus	= 0x00000000;
	gPhrInfo.dCtrlStatus	= 0x00000000;

	return (MASMW_SUCCESS);
}

/****************************************************************************
 *	Phrase_Initialize
 *
 *	Function:
 *			Initialize SMAF/Phrase sequencer.
 *	Argument:
 *
 *	Return:
 *			0	success.
 *			< 0	error.
 *
 ****************************************************************************/
int	Phrase_Initialize(void)
{
	UINT32		i;
	UINT32		dRamAdr;
	UINT32		dRamBlockSize;

	MAPHRCNV_DBGMSG(("Phrase_Initialize\n"));

	/*---	check SMAF/Phrase stream converter ID ----------------------------*/
	if(gPhrInfo.dCreateStatus & (UINT32)MAPHR_MASK_PHRASE) return (-1);

	/*---	Initialize global values -----------------------------------------*/
	gPhrInfo.dPhrStatus		= 0x00000000;
	gPhrInfo.dSlave			= 0x00000000;
	gPhrInfo.pfnEvHandler	= NULL;
	for(i = 0; i < MAPHR_MAX_CHANNEL; i++)	InitApiInfo(i);
	for(i = 0; i < MASMW_NUM_CHANNEL; i++)	InitChInfo(i);

	/*---	MA-5 Sequence Create ---------------------------------------------*/
	if(gPhrInfo.dCreateStatus == 0L) {
		if(ResourceCreate() < MASMW_SUCCESS) {
			return (-1);
		}
	}
	gPhrInfo.dCreateStatus |= (UINT32)MAPHR_MASK_PHRASE;

	/*---	Calucurate RAM address -------------------------------------------*/
	dRamBlockSize = (UINT32)(gPhrInfo.dRamSize >> 2);
	for(i = 0; i < MAPHR_MAX_CHANNEL; i++) {
		dRamAdr = (UINT32)(gPhrInfo.dRamAdr + (dRamBlockSize * i));
		gPhrInfo.sApiInfo[i].dRamAdr = dRamAdr;
		MAPHRCNV_DBGMSG(("Ram Address #%d - %08lX\n", i, dRamAdr));
	}

	return (0);
}

/****************************************************************************
 *	Phrase_GetInfo
 *
 *	Function:
 *			Get device infomation.
 *	Argument:
 *			pDat	pointer to info structure.
 *	Return:
 *			0	success.
 *			< 0	error.
 *
 ****************************************************************************/
int	Phrase_GetInfo(struct info* pDat)
{
	MAPHRCNV_DBGMSG(("Phrase_GetInfo[%08lX] \n", pDat));

	if(pDat == NULL)	return (-1);

	pDat->MakerID		= 0x00430000;			/*	YAMAHA	*/
	pDat->DeviceID		= 0x07;					/*	MA-5	*/
	pDat->VersionID		= 2;
	pDat->MaxVoice		= 4;
	pDat->MaxChannel	= 4;
	pDat->SupportSMAF	= 0x03;					/*	SMAF/Phrase L1 & L2	*/
	pDat->Latency		= (long)(20 * 1000);	/*	20msec	*/

	return (0);
}

/****************************************************************************
 *	Phrase_CheckData
 *
 *	Function:
 *			Check SMAF/Phrase data.
 *	Argument:
 *			pbData	Pointer to the data.
 *			dLen	Size of data
 *	Return:
 *			0		success.
 *			< 0		error
 *
 ****************************************************************************/
int	Phrase_CheckData(unsigned char* pbData, unsigned long dLen)
{
	SINT32	sdRet;

	MAPHRCNV_DBGMSG(("Phrase_CheckData [%08lX %ld] \n", pbData, dLen));

	/*---	check SMAF/Phrase stream converter ID ---------------------------*/
	if(!(gPhrInfo.dCreateStatus & (UINT32)MAPHR_MASK_PHRASE)	||
		(gPhrInfo.sdSeqId < 0L)) {
		return (-1);
	}

	/*---	check parameter -------------------------------------------------*/
	if(pbData == NULL)	return (-1);

	sdRet = malib_smafphrase_checker(pbData, dLen, NULL);
	if(sdRet < MASMW_SUCCESS) {
		return (-1);
	}

	return (0);
}

/****************************************************************************
 *	Phrase_SetData
 *
 *	Function:
 *			Load SMAF/Phrase data.
 *	Argument:
 *			nCh		Sequence Number(0..3)
 *			pbData	Pointer to the data.
 *			dLen	Size of data
 *			nCheck	error check(0:Disable 1:Enable)
 *	Return:
 *			0		success.
 *			< 0		error
 *
 ****************************************************************************/
int	Phrase_SetData(int nCh, unsigned char* pbData,
										unsigned long dLen, int nCheck)
{
	SINT32			sdRet;
	PMAPHRAPIINFO	pAi;

	MAPHRCNV_DBGMSG(("Phrase_SetData [%d %08lX %ld %d] \n",
										 nCh, pbData, dLen, nCheck));

	/*---	check SMAF/Phrase stream converter ID ---------------------------*/
	if(!(gPhrInfo.dCreateStatus & (UINT32)MAPHR_MASK_PHRASE)	||
		(gPhrInfo.sdSeqId < 0L)) {
		return (-1);
	}

	/*---	check parameter -------------------------------------------------*/
	if((nCh < 0) || (MAPHR_MAX_CHANNEL <= nCh))	return (-1);
	if(pbData == NULL)							return (-1);

	/*---	check status (Is status NODATA?) --------------------------------*/
	pAi = &(gPhrInfo.sApiInfo[nCh]);
	if(pAi->Status != MAPHR_STATUS_NODATA)	return (-1);

	/*---	load SMAF/Phrase data -------------------------------------------*/
	InitPhraseInfo(&(pAi->sDataInfo));
	pAi->sDataInfo.dErrChk = (UINT32)((nCheck)? 1 : 0);
	sdRet = malib_smafphrase_checker(pbData, dLen, &(pAi->sDataInfo));
	if(sdRet < MASMW_SUCCESS)	return (-1);

	pAi->dLength = (UINT32)sdRet;

	/*---	setup extend voice ----------------------------------------------*/
	if(pAi->sDataInfo.dVersion == (UINT32)MAPHR_VERSION_LV2) {
		sdRet = SetupVoice2((UINT32)nCh);
		Seek2((UINT32)nCh, 0);	/* seek to top(0ms) */
	}
	else {
		sdRet = SetupVoice((UINT32)nCh);
		Seek1((UINT32)nCh, 0);	/* seek to top(0ms) */
	}

	if(sdRet < MASMW_SUCCESS) return (-1);

	/*---	successful load data --------------------------------------------*/
	pAi->Status	= MAPHR_STATUS_READY;

	/*---	setup volumes ---------------------------------------------------*/
	gPhrInfo.dCtrlStatus |= (UINT32)(MAPHR_CTRL_VOLUME << (nCh << 2));
	return (0);
}

/****************************************************************************
 *	Phrase_Seek
 *
 *	Function:
 *			Seek
 *	Argument:
 *			nCh		Sequence Number(0..3)
 *			dPos	Seek Position[ms]
 *	Return:
 *			0	success.
 *			< 0	error.
 *
 ****************************************************************************/
int	Phrase_Seek(int nCh, long sdPos)
{
	UINT32			i;
	UINT32			dSlave;
	SINT32			sdRet;
	PMAPHRAPIINFO	pAi;

	MAPHRCNV_DBGMSG(("Phrase_Seek[%d %ld] \n", nCh, sdPos));

	/*---	check SMAF/Phrase stream converter ID ---------------------------*/
	if(!(gPhrInfo.dCreateStatus & (UINT32)MAPHR_MASK_PHRASE)	||
		(gPhrInfo.sdSeqId < 0L)) {
		return (-1);
	}
	/*---	check channel ---------------------------------------------------*/
	if((nCh < 0) || (MAPHR_MAX_CHANNEL <= nCh))	return (-1);

	/*---	check status (Is status READY?) ---------------------------------*/
	pAi = &(gPhrInfo.sApiInfo[nCh]);
	if(pAi->Status != MAPHR_STATUS_READY)		return (-1);

	/*---	check position --------------------------------------------------*/
	if((sdPos < 0L) || ((SINT32)pAi->dLength <= sdPos))
		return (-1);

	/*---	is slave ? ------------------------------------------------------*/
	if(gPhrInfo.dSlave & (UINT32)(1L << nCh))	return (-1);

	/*---	seek position ---------------------------------------------------*/
	if(pAi->sDataInfo.dVersion == (UINT32)MAPHR_VERSION_LV2)
		sdRet = Seek2((UINT32)nCh, sd