maphrcnv.c

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

				}
				break;
			case 0x10L : /*	Short type PitchBend	*/
				break;
			case 0x20L :	/*	Short type Modulation	*/
				if((0L < dTmp) && (dTmp < 15L)) {
					pCi->dMod = gdShortModTable[dTmp];
				}
				break;
			case 0x30L :
				dData = (UINT32)pDi->pbSeq[pDi->dDataPosition++];
				switch(dTmp) {
				case 0x00L :	/*	Program Change	*/
					if(dData < 128L) {
						/*	update bank number	*/
						pCi->dBankNo = pCi->dNewBank;
						pCi->dProgNo = dData;
					}
					break;
				case 0x01L :	/*	Bank Select	*/
					BankSelect(dCh, dData);
					break;
				case 0x02L :	/*	Octave Shift	*/
					OctaveShift2(dCh, dData);
					break;
				case 0x03L :	/*	Normal type Modulation	*/
					if(dData < 128L) pCi->dMod = gdNormalModTable[dData];
					break;
				case 0x04L :	/*	Pitch Bend	*/
					if(dData < 128L) {
						pCi->dRange = pCi->dNewRange;
						pCi->dPitch = dData;
					}
					break;
				case 0x05L :	/*	Pitch Bend Range	*/
					if(dData <= 24L) pCi->dNewRange = dData;
					break;
				case 0x06L :	/*	Velocity	*/
					Velocity(dCh, dData);
					break;
				case 0x0AL :	/*	Panpot	*/
					if(dData < 128L) pCi->dPan = dData;
					break;
				case 0x0BL :	/*	Normal type Volume	*/
					if(dData < 128L) pCi->dVolume = dData;
					break;
				default	  :
					break;
				}
				break;
			default	 :
				break;
			}
			break;
		case 0xFF :
			dData = (UINT32)pDi->pbSeq[pDi->dDataPosition++];
			if(dData == 0xF0L) {			/*	Exclusive Message	*/
				dTmp = (UINT32)pDi->pbSeq[pDi->dDataPosition++];
				/*	skip exclusive message	*/
				pDi->dDataPosition += dTmp;
			}
			break;
		default	  :
			dDuration = (UINT32)pDi->pbSeq[pDi->dDataPosition++];
			if(dDuration & 0x80L) {
				pDi->dDataPosition++;
			}
			break;
		}
	}

	return (MASMW_SUCCESS);
}

/****************************************************************************
 *	SetVoice
 *
 *	Function:
 *			register voices for LV1.
 *	Argument:
 *			dPhrCh	Sequence Number(0..3)
 *			dIdx	Register Number(0..3)
 *			pbVoc	Pointer to the voice parameter.
 *			dSize	Size of voice parameter.
 *	Return:
 *			>=0	number of registered voices.
 *			< 0	error code.
 *
 ****************************************************************************/
static SINT32	SetVoice(UINT32 dPhrCh, UINT32 dIdx, UINT8* pbVoc, UINT32 dSize)
{
	UINT32			dBankNo;
	UINT32			dProgNo;
	UINT32			dVocSize;
	SINT32			sdRet;
	PMAPHRAPIINFO	pAi;
	PMALIBVOCINFO	pVi;
	static UINT8	bParam[MAPHR_MA5_4OP_SIZE];

	MASMW_ASSERT(dIdx < MAPHR_MAX_LV1_VOICES);

	pAi = &(gPhrInfo.sApiInfo[dPhrCh]);
	pVi = &(pAi->sDataInfo.sVocInfo[dIdx]);
	dBankNo		= 0x00L;
	dProgNo		= 0x00L;
	dVocSize	= 0L;

	/*	MA-2 2op Voice(Shortest voice parameter) */
	if(dSize < 21L) {
		MAPHRCNV_DBGMSG(("Shortest voice parameter[%ld] \n", dSize));
		return (0L);
	}

	/*	check size	*/
	dVocSize = (UINT32)pbVoc[2];
	if((UINT32)(dVocSize + 3L) > dSize) {
		return (0L);
	}

	/*	check header id	*/
	if(	(pbVoc[0] != 0xFF)		||
		(pbVoc[1] != 0xF0)		||
		(pbVoc[3] != 0x43)		||
		(pbVoc[dVocSize + 2L] != 0xF7)) {
		MAPHRCNV_DBGMSG(("Unkown system exclusive message. \n"));
		return (0L);
	}

	/*	MA-2 FM format setting */
	if(	((dVocSize == 18L) || (dVocSize == 28L))	&&
		(pbVoc[4] == 0x03)) {

		dBankNo		= 0x01L;
		dProgNo		= dIdx;
		dVocSize	-= 3L;
		dVocSize	= ConvertMA3Voice(&(pbVoc[5]), dVocSize, &(bParam[0]));
	}
	/*	MA-3 FM format setting	*/
	else if(((dVocSize == 20L) || (dVocSize == 34L))	&&
			(pbVoc[4] == 0x04)							&&
			(pbVoc[5] == 0x01)) {

		dBankNo		= 0x01L;
		dProgNo		= dIdx;
		dVocSize	-= 4;
		if((dVocSize > (UINT32)MAPHR_MA5_2OP_SIZE) && ((pbVoc[7] & 0x07) < 2))
			dVocSize = (UINT32)MAPHR_MA5_2OP_SIZE;
		machdep_memcpy(&(bParam[0]), &(pbVoc[6]), dVocSize);
	}
	else {
		return (0L);
	}

	/*	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);
	}
	pVi->dBankNo = dBankNo;
	pVi->dProgNo = dProgNo;

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

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

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

/****************************************************************************
 *	SetupVoice
 *
 *	Function:
 *			register voices for LV1.
 *	Argument:
 *			dPhrCh	Sequence Number(0..3)
 *	Return:
 *			0	success.
 *			< 0	error code.
 *
 ****************************************************************************/
static SINT32	SetupVoice(UINT32 dPhrCh)
{
	UINT8*			pbVoc;
	UINT32			dIdx;
	UINT32			dSize;
	UINT32			dChunkId;
	UINT32			dChunkSize;
	SINT32			sdRet;
	PMAPHRAPIINFO	pAi;
	PMALIBPHRINFO	pDi;
	PMALIBVOCINFO	pVi;

	/*	no voice	*/
	pAi = &(gPhrInfo.sApiInfo[dPhrCh]);
	pDi = &(pAi->sDataInfo);
	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(("SetupVoice [%X %08lX-%08lX]\n",
									dPhrCh, pAi->dRamAdr, pAi->dRamEndAdr));

	dIdx	= 0L;
	pbVoc	= pDi->pbVoice;
	dSize	= pDi->dVoiceSize;
	while(	(dSize >= (UINT32)(MAPHR_SIZE_OF_CHUNKHEADER)) &&
			(dIdx < (UINT32)MAPHR_MAX_LV1_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

		/*	default voice chunk	*/
		if(dChunkId == MAPHR_MAKEDWORD('D', 'E', 'V', 'O')) {
			pVi = &(pDi->sVocInfo[dIdx]);
			pVi->dBankNo = 0x00L;
			if(dChunkSize == 0L)
				pVi->dProgNo = 0x00L;
			else
				pVi->dProgNo = (UINT32)(pbVoc[0] & 0x7F);
			dIdx++;
		}
		/*	extend voice chunk	*/
		else if(dChunkId == MAPHR_MAKEDWORD('E', 'X', 'V', 'O')) {
			sdRet = SetVoice(dPhrCh, dIdx, pbVoc, dChunkSize);
			if(sdRet < MASMW_SUCCESS) return (sdRet);
			dIdx++;
		}

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

	return (MASMW_SUCCESS);
}

/****************************************************************************
 *	SetWtBank
 *
 *	Function:
 *			register voices for LV2.
 *	Argument:
 *			pbWave	Pointer to the wave data.
 *			dSize	Size of wave data.
 *			pWtBank	Pointer to the WT bank.
 *	Return:
 *			0	success.
 *			< 0	error code.
 *
 ****************************************************************************/
static SINT32	SetWtBank(UINT8* pbWave, UINT32 dSize, PMAPHRWTBANK pWtBank)
{
	UINT32	dWaveId;
	UINT32	dWaveSize;

	MAPHRCNV_DBGMSG(("SetWtBank [%08lX]\n", dSize));

	if(dSize < 10L)	return (MASMW_ERROR);

	if(	(pbWave[0] != 0xFF)	||
		(pbWave[1] != 0xF1)	||
		(pbWave[4] != 0x43)	||
		(pbWave[5] != 0x05)	||
		(pbWave[6] != 0x00)	||
		(pbWave[7] >= MAPHR_MAX_WAVES)) {

		return (MASMW_ERROR);
	}

	dWaveId		= (UINT32)pbWave[7];
	dWaveSize	= (UINT32)(((UINT32)pbWave[3] << 8) | (UINT32)pbWave[2]);

	/*	check size	*/
	if(dWaveSize < 5L)					return (MASMW_ERROR);
	if((dWaveSize + 4L) > dSize)		return (MASMW_ERROR);
	if(pbWave[dWaveSize + 3L] != 0xF7)	return (MASMW_ERROR);

	/*	add wt bank	*/
	if(pWtBank[dWaveId].pbWave == NULL) {
		pWtBank[dWaveId].pbWave	= &(pbWave[8]);
		pWtBank[dWaveId].dSize	= (dWaveSize - 5L);
		MAPHRCNV_DBGMSG(("Add WT Bank[ID:%02X %08lX]\n", dWaveId, dWaveSize - 5L));
	}
	else {
		MAPHRCNV_DBGMSG(("Already added wave data[ID:%02X]\n", dWaveId));
	}
	return (MASMW_SUCCESS);
}

/****************************************************************************
 *	SetWaveData
 *
 *	Function:
 *			register WT data for LV2.
 *	Argument:
*			dPhrCh	Sequence Number(0..3)
 *			dWaveId	wave id(0..15)
 *			pWtBank	Pointer to the WT bank.
 *	Return:
 *			>=0	success.
 *			< 0	error code.
 *
 ****************************************************************************/
static SINT32	SetWaveData(UINT32 dPhrCh, UINT32 dWaveId, PMAPHRWTBANK pWtBank)
{
	SINT32			sdRet;
	UINT32			dEndAdr;
	PMAPHRAPIINFO	pAi;
	PMAPHRWTBANK	pWi;

	MAPHRCNV_DBGMSG(("SetWaveData [%02X]\n", dWaveId));

	if(dWaveId >= (UINT32)MAPHR_MAX_WAVES) {
		MAPHRCNV_DBGMSG(("Invalid wave id[%02X] \n", dWaveId));
		return (MASMW_SUCCESS);
	}

	pAi	= &(gPhrInfo.sApiInfo[dPhrCh]);
	pWi	= &(pWtBank[dWaveId]);
	if(pWi->pbWave == NULL) {
		MAPHRCNV_DBGMSG(("No wave data[%02X] \n", dWaveId));
		return (MASMW_SUCCESS);
	}

	/*	already registered	*/
	if(pWi->dRamAdr != 0x00000000) {
		return (SINT32)(pWi->dRamAdr);
	}

	/*	ram check	*/
	dEndAdr = pAi->dRamAdr + pWi->dSize;
	if(dEndAdr & 0x00000001) dEndAdr++;
	dEndAdr += MAPHR_MA5_WT_SIZE;	/*	WT data + voice	*/
	if(dEndAdr > pAi->dRamEndAdr) {
		MAPHRCNV_DBGMSG(("RAM Over!! [%08lX %08lX]\n", pAi->dRamAdr, pWi->dSize));
		return (MASMW_SUCCESS);
	}

	sdRet = MaDevDrv_SendDirectRamData(pAi->dRamAdr, 0, pWi->pbWave, pWi->dSize);
	if(sdRet < MASMW_SUCCESS) {
		MAPHRCNV_DBGMSG(("MaDevDrv_SendDirectRanData[Return:%ld] \n", sdRet));
		return (sdRet);
	}

	/*	update ram address	*/
	pWi->dRamAdr = pAi->dRamAdr;
	pAi->dRamAdr += pWi->dSize;
	if(pAi->dRamAdr & 0x00000001) pAi->dRamAdr++;

	return (SINT32)(pWi->dRamAdr);
}

/****************************************************************************
 *	SetVoice2
 *
 *	Function:
 *			register voices for LV2.
 *	Argument:
 *			dPhrCh	Sequence Number(0..3)
 *			pbVoc	Pointer to the voice parameter.
 *			dSize	Size of voice parameter.
 *			pWtBank	Pointer to the WT bank.
 *	Return:
 *			>=0	number of registered voices.
 *			< 0	error code.
 *
 ****************************************************************************/
static SINT32	SetVoice2(UINT32 dPhrCh, UINT8* pbVoc, UINT32 dSize,
														 PMAPHRWTBANK pWtBank)
{
	UINT32			i;
	UINT32			dSynth;
	UINT32			dWaveId;
	UINT32			dBankNo;
	UINT32			dProgNo;
	UINT32			dDrumKey;
	UINT32			dVocSize;
	SINT32			sdRet;
	SINT32			sdWaveAdr;
	PMAPHRAPIINFO	pAi;
	PMALIBPHRINFO	pDi;
	PMALIBVOCINFO	pVi;
	static UINT8	bParam[MAPHR_MA5_4OP_SIZE];

	pAi	= &(gPhrInfo.sApiInfo[dPhrCh]);
	pDi = &(pAi->sDataInfo);
	dSynth		= 0x00L;
	dBankNo		= 0x00L;
	dProgNo		= 0x00L;
	dWaveId		= 0x00L;
	dDrumKey	= 0L;
	dVocSize	= 0L;

	/*	MA-5 WT Voice(Shortest voice parameter) */
	if(dSize < 25L) {
		MAPHRCNV_DBGMSG(("Shortest voice parameter[%ld] \n", dSize));
		return (0L);
	}

	/*	check size	*/
	dVocSize = (UINT32)pbVoc[2];
	if((UINT32)(dVocSize + 3L) > dSize) {
		return (0L);
	}

	/*	check header id	*/
	if(	(pbVoc[0] != 0xFF)		||
		(pbVoc[1] != 0xF0)		||
		(pbVoc[3] != 0x43)		||
		(pbVoc[4] != 0x05)		||
		(pbVoc[dVocSize + 2] != 0xF7)) {
		MAPHRCNV_DBGMSG(("Unkown system exclusive message. \n"));
		return (0L);
	}

	/*	MA-5 FM format setting */
	if(	((dVocSize == 23L) || (dVocSize == 37L)) && (pbVoc[5] == 0x01)) {
		dSynth		= 1L;
		dBankNo		= (UINT32)pbVoc[6];
		dProgNo		= (UINT32)pbVoc[7];
		dDrumKey	= (UINT32)pbVoc[8];
		dVocSize	-= 7L;
		pbVoc		+= 9;

		if(dDrumKey > 127L) {
			MAPHRCNV_DBGMSG(("Invalid drum key[%08lX] \n", dDrumKey));
			return (0L);
		}

		if(	(dVocSize > (UINT32)MAPHR_MA5_2OP_SIZE)	&&
			((UINT8)(pbVoc[1] & 0x07) < 2)) {
			dVocSize = (UINT32)MAPHR_MA5_2OP_SIZE;
		}
	}
	/*	MA-5 WT format setting	*/
	else if((dVocSize == 22L) && (pbVoc[5] == 0x02)) {
		dSynth		= 2L;
		dBankNo		= (UINT32)pbVoc[6];
		dProgNo		= (UINT32)pbVoc[7];
		dDrumKey	= (UINT32)(((UINT32)pbVoc[8] << 8) | (UINT32)pbVoc[9]);
		dWaveId		= (UINT32)pbVoc[23];