maphrcnv.c

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

						else if((pbExMsg[3] & 0xF0) == 0xB0) {
							pCi->bExNoteFlag |= 0x01;
							pCi->bRegL = pbExMsg[4];
						}
					}
					else if((pbExMsg[0] == 0x43)	&&
							(pbExMsg[1] == 0x04)	&&
							(pbExMsg[2] == 0x02)	&&
							(pbExMsg[5] == 0xF7))		/*	Pitch Bend Range	*/
					{
						bCh	= (UINT8)((pbExMsg[3] & 0x03) + (phr_id << 2));
						pCi	= &(gChInfo[bCh]);
						pCi->bRange	= (UINT8)((pbExMsg[4] <= 24) ? pbExMsg[4] : 24);
					}
				}

				/*	skip exclusive message	*/
				pPi->dwDataPosition += dwSize;
			}
			break;
		default	  :
			dwDuration = (UINT32)pPi->pbSequenceChunk[pPi->dwDataPosition++];
			if(dwDuration & 0x80) {
				pPi->dwDataPosition++;
			}
			break;
		}
	}

	return (MASMW_SUCCESS);
}


/*=============================================================================
//	Function Name	:	SINT32	MaPhr_Load(UINT8 phr_id, UINT8* file_ptr, UINT32 file_size, UINT8 mode,
//												SINT32 (*func)(UINT8 id), void* ext_args)
//
//	Description		:	Load data
//
//	Argument		:	phr_id		... Phrase ID (0..4)
//						file_ptr	...	Pointer to the data
//						file_size	...	Data size (Byte)
//						mode		...	Error check (0:No  1:Yes  2:Check Only)
//						func		...	Pointer to the call back function
//						ext_args	...	NULL
//
//	Return			:	0:NoError  <0:Error Code
//
=============================================================================*/
static SINT32	MaPhr_Load(UINT8 phr_id, UINT8* file_ptr, UINT32 file_size, UINT8 mode, SINT32 (*func)(UINT8 id), void* ext_args)
{
	UINT8	bMode;
/*	UINT16	wErrStatus; */
	SINT32	sdResult;
	(void)ext_args;

	MAPHRCNV_DBGMSG(("MaPhr_Load\n"));

	/*	set register number	*/
	bMode = 0x00;
	if(mode >= 1) {
		bMode |= CHKMODE_ENABLE;
		if(mode == 3) bMode |= CHKMODE_CNTIONLY;
	}

	/*	Check SMAF/Phrase data	*/
/*
	wErrStatus = PHRASE_DATA_NOERROR;
	SmafPhrChecker(phr_id, bMode, file_ptr, file_size, &wErrStatus);
	if(wErrStatus) {
		MAPHRCNV_DBGMSG(("Error : Invalid SMAF/Phrase [%04X] \n", wErrStatus));

		if(wErrStatus & PHRASE_DATA_SIZE)		return (MASMW_ERROR_CHUNK_SIZE);
		if(wErrStatus & PHRASE_DATA_CLASS)		return (MASMW_ERROR_CONTENTS_CLASS);
		if(wErrStatus & PHRASE_DATA_TYPE)		return (MASMW_ERROR_CONTENTS_TYPE);
		if(wErrStatus & PHRASE_DATA_CHUNK)		return (MASMW_ERROR_CHUNK);
		if(wErrStatus & PHRASE_DATA_SHORTLEN)	return (MASMW_ERROR_SHORT_LENGTH);

		return (MASMW_ERROR_FILE);
	}
*/
	sdResult = SmafPhrChecker(phr_id, bMode, file_ptr, file_size);
	if (sdResult < 0)			return sdResult;

	gApiInfo[phr_id].gPhraseInfo.CallbackFunc = func;

	return (MASMW_SUCCESS);
}

/*=============================================================================
//	Function Name	:	SINT32	MaPhr_Standby(UINT8 phr_id, void* ext_args)
//
//	Description		:	Standby process of converter data (register voices)
//
//	Argument		:	phr_id		...	Phrase ID (0..3)
//						ext_args	...	NULL
//
//	Return			:	0:NoError <0:Error Code
//
=============================================================================*/
static SINT32	MaPhr_Standby(UINT8 phr_id, void* ext_args)
{
	UINT8		i;
	UINT8		bCh;
	UINT8		bVoiceParam[MA3VOICE_PARAM_SIZE];
	UINT32		dwVocAdr;
	UINT32		dwSize;
	PPHRINFO	pPi;
	PVOCINFO	pVi;
	(void)ext_args;

	MAPHRCNV_DBGMSG(("MaPhr_Standby [%X]\n", phr_id));

	pPi = &(gApiInfo[phr_id].gPhraseInfo);

	pPi->dwTimer		= 0L;
	pPi->dwCurrentTime	= 0L;
	pPi->dwDataPosition	= 0L;

	/*	Initialize each channel info	*/
	for(i = 0; i < MAX_PHRASE_SLOT; i++) {
		bCh = (UINT8)(i + (phr_id << 2));
		InitChInfo(bCh);
	}

	dwVocAdr = gApiInfo[phr_id].gdwRamAddr;
	MAPHRCNV_DBGMSG((" dwVocAdr [%X]\n", dwVocAdr));
	if (dwVocAdr != 0xFFFFFFFF) {
	for(i = 0; i < MAX_PHRASE_VOICES; i++)
	{
		/*	extend voice	*/
		pVi = &(pPi->VocInfo[i]);
		MAPHRCNV_DBGMSG((" bBankNo [%X]\n", pVi->bBankNo));
		if(pVi->bBankNo != 0x00) {
			MAPHRCNV_DBGMSG((" bType [%X]\n", pVi->bType));
			if(pVi->bType == VOICE_TYPE_MA2) {	/*	MA-2 voice type	*/
				dwSize = ConvertMA3Voice(pVi->pbVoice, pVi->bSize, &(bVoiceParam[0]));
				MaDevDrv_SendDirectRamData(dwVocAdr, 0, &(bVoiceParam[0]), dwSize);
			}
			else {								/*	MA-3 voice type	*/
				machdep_memcpy(&(bVoiceParam[0]), pVi->pbVoice, pVi->bSize);
				/* Prohibit XOF=1                                               */
				bVoiceParam[2] = (UINT8)(bVoiceParam[2] & 0xF7);
				bVoiceParam[9] = (UINT8)(bVoiceParam[9] & 0xF7);
				if (pVi->bSize > 16) {
					bVoiceParam[16] = (UINT8)(bVoiceParam[16] & 0xF7);
					bVoiceParam[23] = (UINT8)(bVoiceParam[23] & 0xF7);
				}
				MaDevDrv_SendDirectRamData(dwVocAdr, 0, &(bVoiceParam[0]), (UINT32)pVi->bSize);
			}

			/*	Remove	*/
			MaSndDrv_SetVoice(	gdwPhrId,
								pVi->bBankNo,	/*	Bank Number					*/
								pVi->bProgNo,	/*	Program Number				*/
								(UINT8)1,		/*	Synth Mode					*/
								(UINT8)0,		/*	Durum Key					*/
								0xFFFFFFFF);	/*	Registered voice address	*/
			/*	Set		*/
			MaSndDrv_SetVoice(	gdwPhrId,
								pVi->bBankNo,	/*	Bank Number					*/
								pVi->bProgNo,	/*	Program Number				*/
								(UINT8)1,		/*	Synth Mode					*/
								(UINT8)0,		/*	Durum Key					*/
								dwVocAdr);		/*	Registered voice address	*/

			dwVocAdr += MA3VOICE_PARAM_SIZE;
		}
	}
	}

	return (MASMW_SUCCESS);
}

/*=============================================================================
//	Function Name	:	SINT32	MaPhr_Seek(UINT8 phr_id, UINT32 pos, UINT8 flag, void* ext_args)
//
//	Description		:	Seek process of converter data
//
//	Argument		:	phr_id		...	Phrase ID (0..3)
//						pos			...	Starting position of play back (msec)
//						flag		...	Wait mode 0:No wait before start 1:Wait before start
//						ext_args	...	NULL
//
//	Return			:	0:NoError  <0:Error Code
//
=============================================================================*/
SINT32	MaPhr_Seek(UINT8 phr_id, UINT32 pos, UINT8 flag, void* ext_args)
{
	UINT8	i;
	UINT32	dwSlave;
	SINT32	lRet = MASMW_SUCCESS;
	(void)flag;
	(void)ext_args;

	MAPHRCNV_DBGMSG(("MaPhr_Seek\n"));

	/*	Master Seek	*/
	lRet = Seek(phr_id, pos);
	if(lRet != MASMW_SUCCESS) {
		return (lRet);
	}

	/*	Synchronization control	*/
	dwSlave = gApiInfo[phr_id].slave;
	for(i = 0; i < MAX_PHRASE_CHANNEL; i++) {
		if(dwSlave & (UINT32)(0x01L << i)) {	/*	synchronization	*/
			if (gApiInfo[i].status != ID_STATUS_READY)
				continue;
			lRet = Seek(i, pos);
			if (lRet != MASMW_SUCCESS) continue;
		}
	}


	return (MASMW_SUCCESS);
}

/*=============================================================================
//	Function Name	:	SINT32	MaPhr_Start(UINT8 phr_id, UINT16 loop)
//
//	Description		:	Start process of converter data
//
//	Argument		:	phr_id		...	Phrase ID (0..3)
//						loop		...	loop count
//
//	Return			:	0:NoError  <0:Error Code
//
=============================================================================*/
static SINT32	MaPhr_Start(UINT8 phr_id, UINT16 loop)
{
	UINT8	i;
	UINT32	dwSlave;

	MAPHRCNV_DBGMSG(("MaPhr_Start[Loop:%04X] \n", loop));

	/*	Master Start	*/
	if (gApiInfo[phr_id].gPhraseInfo.dwPlayTime <= MIN_PHRASE_DATA_LENGTH)
		return (MASMW_ERROR);
	gApiInfo[phr_id].loop = loop;
	gApiInfo[phr_id].status = ID_STATUS_PLAY;
	gdwPhrStatus |= gMaskStart[phr_id];
	
	/*	Synchronization control	*/
	dwSlave = gApiInfo[phr_id].slave;
	for(i = 0; i < MAX_PHRASE_CHANNEL; i++) {
		if(dwSlave & (UINT32)(0x01L << i)) {	/*	synchronization	*/
			if (gApiInfo[i].status != ID_STATUS_READY) continue;
			if (gApiInfo[i].gPhraseInfo.dwPlayTime <= MIN_PHRASE_DATA_LENGTH)
				continue;
			gApiInfo[i].loop = loop;
			gApiInfo[i].status = ID_STATUS_PLAY;
			gdwPhrStatus |= gMaskStart[i];
		}
	}

	/* control sequencer */
	if (!(gbSeqStatus & MASK_STATUS_PHRASE)) {
		gbSeqStatus |= MASK_STATUS_PHRASE;
		MaSndDrv_ControlSequencer(gdwPhrId, 1);
	}

	return (MASMW_SUCCESS);
}

/*=============================================================================
//	Function Name	:	SINT32	MaPhr_Stop(UINT8 phr_id)
//
//	Description		:	Stop process of converter data
//
//	Argument		:	phr_id		...	Phrase ID (0..3)
//
//	Return			:	0:NoError  <0:Error Code
//
=============================================================================*/
static SINT32	MaPhr_Stop(UINT8 phr_id)
{
#if !MA_STOPWAIT
	UINT8		bCh;
#endif
	UINT8		i;
	UINT32		dwSlave;
	UINT32		dwMask;
#if MA_STOPWAIT
	SINT32		lTimeOut;
#endif
	IDSTATUS	status;

	MAPHRCNV_DBGMSG(("MaPhr_Stop[%d %02X] \n", phr_id, gbPlayStatus));

	dwMask = 0;

	/*	Master Stop	*/
#if MA_STOPWAIT
	gApiInfo[phr_id].status = ID_STATUS_ENDING;
	dwMask |= gMaskStop[phr_id];
	gdwPhrStatus |= gMaskStop[phr_id];
#else
	gdwPhrStatus &= ~(gMaskStart[phr_id]|gMaskPause[phr_id]|gMaskRestart[phr_id]);
	/* Mute */
	bCh = (UINT8)(phr_id << 2);
	CnvAllSoundOff(bCh);
	CnvAllSoundOff((UINT8)(bCh+1));
	CnvAllSoundOff((UINT8)(bCh+2));
	CnvAllSoundOff((UINT8)(bCh+3));

	gbPauseStatus &= ~gMaskPlay[phr_id];
	gbPlayStatus &= ~gMaskPlay[phr_id];
	gApiInfo[phr_id].status = ID_STATUS_READY;

	/* seek to top */
	Seek(phr_id, 0L);
#endif

	/*	Synchronization control	*/
	dwSlave = gApiInfo[phr_id].slave;
	for(i = 0; i < MAX_PHRASE_CHANNEL; i++) {
		if(dwSlave & (UINT32)(0x01L << i)) {	/*	synchronization	*/
			status = gApiInfo[i].status;
#if 0
			if(status == ID_STATUS_READY) continue;
#endif
			if((status != ID_STATUS_PLAY) && (status != ID_STATUS_PAUSE))
				continue;
#if MA_STOPWAIT
			gApiInfo[i].status = ID_STATUS_ENDING;
			dwMask |= gMaskStop[i];
			gdwPhrStatus |= gMaskStop[i];
#else
			gdwPhrStatus &= ~(gMaskStart[i] | gMaskPause[i] | gMaskRestart[i]);
			/* Mute */
			bCh = (UINT8)(i << 2);
			CnvAllSoundOff(bCh);
			CnvAllSoundOff((UINT8)(bCh+1));
			CnvAllSoundOff((UINT8)(bCh+2));
			CnvAllSoundOff((UINT8)(bCh+3));

			gbPauseStatus &= ~gMaskPlay[i];
			gbPlayStatus &= ~gMaskPlay[i];
			gApiInfo[i].status = ID_STATUS_READY;

			/* seek to top */
			Seek(i, 0L);
#endif
		}
	}

#if MA_STOPWAIT
	lTimeOut = PHRASE_WAIT_TIMEOUT;
	while ((gdwPhrStatus & dwMask) && lTimeOut > 0) {
		machdep_Sleep(5);
		lTimeOut -= 5;
	}
#endif

	/*	No played Phrase	*/
	if((gbPlayStatus | gbPauseStatus | gdwPhrStatus) == 0x00) {
		if (gbSeqStatus  & MASK_STATUS_PHRASE) {
			gbSeqStatus &= ~ MASK_STATUS_PHRASE;
			MaSndDrv_ControlSequencer(gdwPhrId, 0);
		}
	}

	return (MASMW_SUCCESS);
}

/*=============================================================================
//	Function Name	:	SINT32	MaPhr_Restart(UINT8 phr_id)
//
//	Description		:	Restart process of converter data
//
//	Argument		:	phr_id		...	Phrase ID (0..3)
//
//	Return			:	0:NoError  <0:Error Code
//
=============================================================================*/
static SINT32	MaPhr_Restart(UINT8 phr_id)
{
	UINT8	i;
	UINT32	dwSlave;

	MAPHRCNV_DBGMSG(("MaPhr_Restart[%d] \n", phr_id));

	/*	Master Restart	*/
	gApiInfo[phr_id].status = ID_STATUS_PLAY;
	if (gdwPhrStatus & gMaskPause[phr_id])
		gdwPhrStatus &= ~gMaskPause[phr_id];
	else
		gdwPhrStatus |= gMaskRestart[phr_id];
	
	/*	Synchronization control	*/
	dwSlave = gApiInfo[phr_id].slave;
	for(i = 0; i < MAX_PHRASE_CHANNEL; i++) {
		if(dwSlave & (UINT32)(0x01L << i)) {	/*	synchronization	*/
			if (gApiInfo[i].status != ID_STATUS_PAUSE)
				continue;
			gApiInfo[i].status = ID_STATUS_PLAY;
			if (gdwPhrStatus & gMaskPause[i])
				gdwPhrStatus &= ~gMaskPause[i];
			else
				gdwPhrStatus |= gMaskRestart[i];
		}
	}

	/* control sequencer */
	if (!(gbSeqStatus & MASK_STATUS_PHRASE)) {
		gbSeqStatus |= MASK_STATUS_PHRASE;
		MaSndDrv_ControlSequencer(gdwPhrId, 1);
	}

	return (MASMW_SUCCESS);
}

/*=============================================================================
//	Function Name	:	SINT32	MaPhr_Pause(UINT8 phr_id)
//
//	Description		:	Stop process of converter data
//
//	Argument		:	phr_id		...	Phrase ID (0..3)
//
//	Return			:	0:NoError  <0:Error Code
//
=============================================================================*/
static SINT32	MaPhr_Pause(UINT8 phr_id)
{
	UINT8		i;
	UINT32		dwSlave;
	IDSTATUS	status;

	MAPHRCNV_DBGMSG(("MaPhr_Pause[%d %02X] \n", phr_id, gbPlayStatus));

	/*	Master Pause	*/
	gApiInfo[phr_id].status = ID_STATUS_PAUSE;
	if (gdwPhrStatus & gMaskRestart[phr_id])
		gdwPhrStatus &= ~gMaskRestart[phr_id];
	else
		gdwPhrStatus |= gMaskPause[phr_id];

	/*	Synchronization control	*/
	dwSlave = gApiInfo[phr_id].slave;
	for(i = 0; i < MAX_PHRASE_CHANNEL; i++) {