marmdcnv.c

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

	MaSndDrv_SetVolShift(gpRmdInfo->sdSeqID, 2, 2);	/* WT +12dB              */

	gpRmdInfo->dRamBase = dRam;
	gpRmdInfo->dRamSize = dSize;
	gpRmdInfo->dMasterVolume = 127L;
	gpRmdInfo->dOpend = 1;
	gpRmdInfo->dMaxGain = RMD_MAX_GAIN;				/* RMD_MAX_GAIN[dB]      */
	gpRmdInfo->dRamOffset = 0;
	for (i = 0; i < MAX_NUM_OF_WAVES ; i++) gpRmdInfo->dWtAdrTable[i] = 0;

	SendMasterVolume(gpRmdInfo->dMaxGain);

	return (SendGmOn());
}


/****************************************************************************
 *	MaRmdCnv_Close(SINT32 sdFileID, void* pvExtArgs)
 *
 *	Description
 *		Disable MIDI
 *	Param
 *		sdFileID		...	file ID
 *		ext_args		...	NULL
 *	Return
 *		0 : NoError, < 0 : Error
 ****************************************************************************/
SINT32	MaRmdCnv_Close(SINT32 sdFileID, void* pvExtArgs)
{
	UINT32	dCh;
	(void)pvExtArgs;

	MARMDCNV_DBGMSG(("MaRmdCnv_Close[%ld] \n", sdFileID));

	if ((sdFileID < 0) || (sdFileID != gpRmdInfo->sdFileID))
	{
		return (MASMW_ERROR);
	}

	for (dCh = 0; dCh < 16; dCh++)
	{
		MaSndDrv_SetCommand(gpRmdInfo->sdSeqID, -1, MASNDDRV_CMD_ALL_SOUND_OFF, dCh, 0L, 0L);
	}

	MaSndDrv_Free(gpRmdInfo->sdSeqID);

	gpRmdInfo->sdSeqID = -1;
	gpRmdInfo->dOpend = 0;

	return (MASMW_SUCCESS);
}


/****************************************************************************
 *	MaRmdCnv_Standby(SINT32 sdFileID, void* pvExtArgs)
 *
 *	Description
 *		Initialize MIDI Engine
 *	Param
 *		sdFileID		...	file ID
 *		pvExtArgs		...	NULL
 *	Return
 *		0 : NoError, < 0 : Error
 ****************************************************************************/
SINT32	MaRmdCnv_Standby(SINT32 sdFileID, void* pvExtArgs)
{
	(void)pvExtArgs;

	MARMDCNV_DBGMSG(("MaRmdCnv_Standby[%ld] \n", sdFileID));

	if ((sdFileID < 0) || (sdFileID != gpRmdInfo->sdFileID))
	{
		return (MASMW_ERROR);
	}

	return (MASMW_SUCCESS);
}


/****************************************************************************
 *	MaRmdCnv_Seek(SINT32 sdFileID, UINT32 dPos, void* pvExtArgs)
 *
 *	Description
 *		No effect
 *	Praram
 *		sdFileID		...	file ID
 *		dPos			...	Start point(msec)
 *		pvExtArgs		...	NULL
 *	Return
 *		0 : NoError, < 0 : Error
 ****************************************************************************/
SINT32	MaRmdCnv_Seek(SINT32 sdFileID, UINT32 dPos, void* pvExtArgs)
{
	(void)dPos;
	(void)pvExtArgs;

	MARMDCNV_DBGMSG(("MaRmdCnv_Seek[%ld %ld] \n", sdFileID, dPos));

	if ((sdFileID < 0) || (sdFileID != gpRmdInfo->sdFileID))
	{
		return (MASMW_ERROR);
	}

	return (MASMW_SUCCESS);
}


/****************************************************************************
 *	MaRmdCnv_Start(SINT32 sdFileID, void* pvExtArgs)
 *
 *	Description
 *		No effect
 *	Param
 *		sdFileID	...	file ID
 *		pvExtArgs	...	NULL
 *	Return
 *		0 : NoError, < 0 : Error
 ****************************************************************************/
SINT32	MaRmdCnv_Start(SINT32 sdFileID, void* pvExtArgs)
{
	(void)pvExtArgs;

	MARMDCNV_DBGMSG(("MaRmdCnv_Start[%p] \n", pvExtArgs));

	if ((sdFileID < 0) || (sdFileID != gpRmdInfo->sdFileID))
	{
		return (MASMW_ERROR);
	}
	if (gpRmdInfo->dIntervalTime > 0) MaSndDrv_ControlSequencer(gpRmdInfo->sdSeqID, 1);

	return (MASMW_SUCCESS);
}


/****************************************************************************
 *	MaRmdCnv_Stop(SINT32 sdFileID, void* pvExtArgs)
 *
 *	Description
 *		Stop MIDI Play
 *	Param
 *		sdFileID		...	file ID
 *		pvExtArgs		...	NULL
 *	Return
 *		0 : NoError, < 0 : Error
 ****************************************************************************/
SINT32	MaRmdCnv_Stop(SINT32 sdFileID, void* pvExtArgs)
{
	UINT32	dCh;
	(void)pvExtArgs;
	
	MARMDCNV_DBGMSG(("MaRmdCnv_Stop[%ld] \n", sdFileID));

	if ((sdFileID < 0) || (sdFileID != gpRmdInfo->sdFileID))
	{
		return (MASMW_ERROR);
	}

	if (gpRmdInfo->dIntervalTime > 0) MaSndDrv_ControlSequencer(gpRmdInfo->sdSeqID, 0);

	for (dCh = 0; dCh < 16; dCh++)
	{
		MaSndDrv_SetCommand(gpRmdInfo->sdSeqID, -1, MASNDDRV_CMD_ALL_SOUND_OFF, dCh, 0, 0);
	}
	
	return (MASMW_SUCCESS);
}


/****************************************************************************
 *	SINT32	MaRmdCnv_SetShortMsg(SINT32 sdFileID, UINT32 dMsg)
 *
 *	Description
 *		Send MIDI short message
 *	Param
 *		sdFileID		...	file ID
 *		dMsg			...	MIDI message
 *	Return
 *		0 : NoError, < 0 : Error
 ****************************************************************************/
static SINT32	MaRmdCnv_SetShortMsg(SINT32 sdFileID, UINT32 dMsg)
{
	UINT32	dMsg1, dMsg2, dMsg3;
	UINT32	dCh;

	static SINT32 (*fnMidiMsg[16])(UINT32 dChannel, UINT32 dPara1, UINT32 dPara2) =
	{
		ErrorFunction,	ErrorFunction,	ErrorFunction,	ErrorFunction, 
		ErrorFunction, 	ErrorFunction,	ErrorFunction,	ErrorFunction, 
		SendNoteOff,	SendNoteOn,		NotSupported,	SendControl,
		SendProgram,	NotSupported,	SendPitchBend,	NotSupported
	};

	if ((sdFileID < 0) || (sdFileID != gpRmdInfo->sdFileID))
	{
		return (MASMW_ERROR);
	}

	MARMDCNV_DBGMSG(("MaRmdCnv_SetShortMsg[%08lX]\n", dMsg));

	dMsg1 = (dMsg & 0xf0) >> 4;
	dCh   = dMsg & 0x0f;
	dMsg2 = (dMsg >> 8) & 0x7f;
	dMsg3 = (dMsg >> 16) & 0x7f;

	return (fnMidiMsg[dMsg1](dCh, dMsg2, dMsg3));
}


/****************************************************************************
 *	MaRmdCnv_SetLongMsg(SINT32 file_id, UINT8* pbMsg, UINT32 dSize)
 *
 *	Description
 *		Send MIDI Long message
 *	Param
 *		file_id		...	file ID
 *		pbMsg		...	pointer to the SysEx meassage
 *		dSize		...	Size of the message[byte]
 *	Return
 *		0 : NoError, < 0 : Error
 ****************************************************************************/
static SINT32	MaRmdCnv_SetLongMsg(SINT32 sdFileID, UINT8* pbMsg, UINT32 dSize)
{
	SINT32	sdRet;
	UINT32	dBk, dPg, dOnKey;
	UINT32	dBl, dPc, dFlg;
	UINT32	dCh;
	UINT32	dKey, dAdr;
	SINT32	sdRom;
	UINT32	dWsize;
	UINT32	dWaveID;
	UINT8	bVoice[32];

	if ((sdFileID < 0) || (sdFileID != gpRmdInfo->sdFileID))
	{
		return (MASMW_ERROR);
	}

	MARMDCNV_DBGMSG(("MaRmdCnv_SetLongMsg[%p, %ld] \n", pbMsg, dSize));

	sdRet = MASMW_SUCCESS;
	if (dSize < 6) return (MASMW_SUCCESS);
	if (pbMsg[0] != 0xf0) return (MASMW_ERROR);
	if (pbMsg[dSize - 1] != 0xf7) return (MASMW_ERROR);
	
	if ((pbMsg[1] == 0x7e) &&
	    (pbMsg[2] == 0x7f) &&
	    (pbMsg[3] == 0x09) &&
	    ((pbMsg[4] == 0x01) || (pbMsg[4] == 0x02) || (pbMsg[4] == 0x03)) &&
	    (dSize == 6))
	{
		/* GM L1/L2 SystemOn/Off : 0xF0 0x7E 0x7F 0x09 (0x01/0x02/0x03) 0xF7 */
		return (SendGmOn());
	}

	if ((pbMsg[1] == 0x7f) &&
	    (pbMsg[2] == 0x7f) &&
	    (pbMsg[3] == 0x04) &&
	    (pbMsg[4] == 0x01) &&
	    (dSize == 8))
	{
		/* Universal MasterVolume : 0xF0 0x7F 0x7F 0x04 0x01 LL HH 0xF7 */
		gpRmdInfo->dMasterVolume = pbMsg[6] & 0x7f;
		SendExpression(0, gpRmdInfo->dExpressionTable[0]);
		for (dCh = 0; dCh < 16; dCh++) SendExpression(dCh, gpRmdInfo->dExpressionTable[dCh]);
		return (MASMW_SUCCESS);
	}
	
	if ((pbMsg[1] != 0x43) ||
	    (pbMsg[2] != 0x79) ||
	    (pbMsg[3] != 0x06) ||
	    (pbMsg[4] != 0x7f) ||
	    (dSize < 8)) return (MASMW_SUCCESS);

	switch (pbMsg[5])
	{
	case 0x00:		/* Max Gain : 0xF0 0x43 0x79 0x06 0x7F 0x00 VV 0xF7 */
		if (dSize != 8) return (MASMW_ERROR);
		gpRmdInfo->dMaxGain = (UINT8)(pbMsg[6] & 0x7f);
		SendMasterVolume(gpRmdInfo->dMaxGain);
		return (MASMW_SUCCESS);
	
	case 0x10:		/* UserEvent : 0xF0 0x43 0x79 0x06 0x7F 0x10 VV 0xF7 */
		if (dSize != 8) return (MASMW_ERROR);
		if (gpRmdInfo->pfnCallbackFunc == NULL) return (MASMW_ERROR);
		return (gpRmdInfo->pfnCallbackFunc((UINT8)(pbMsg[6] & 0x0f)));
	
	case 0x01:		/* Set Voice params : 0xF0 0x43 0x79 0x06 0x7F 0x01 BH BL PC KY FG ... 0xF7 */
		if (dSize < 31) return (MASMW_ERROR);
		dBl = (UINT32)(pbMsg[7] & 0x7f);
		dPc = (UINT32)(pbMsg[8] & 0x7f);
		dOnKey = (UINT32)(pbMsg[9] & 0x7f);
		dFlg = (UINT32)(pbMsg[10] + 1);

		switch (pbMsg[6])
		{
		case 0x7c:
			dBk = 1 + dBl;
			dPg = dPc;
			break;
		case 0x7d:
			dBk = (UINT32)(129 + dPc);
			dPg = dOnKey;
			break;
		default:
			return (MASMW_ERROR);
		}

		dAdr = gpRmdInfo->dRamBase + gpRmdInfo->dRamOffset;

		switch (dSize)
		{
		case 31:	/* WT */
			if (dFlg != 2) return (MASMW_ERROR);
			if ((gpRmdInfo->dRamOffset + 13) > gpRmdInfo->dRamSize) return (MASMW_ERROR);
			Decode7Enc(&pbMsg[11], 19, bVoice, 16);

			dKey = ((UINT32)bVoice[0] << 8) | (UINT32)bVoice[1];
			dWaveID = bVoice[15];

			if (dWaveID < 128)
			{
				if (dWaveID >= MAX_NUM_OF_WAVES)  return (MASMW_ERROR);
				if (gpRmdInfo->dWtAdrTable[dWaveID] == 0) return (MASMW_ERROR);
				bVoice[9] = (UINT8)((gpRmdInfo->dWtAdrTable[dWaveID] >> 8) & 0xff);
				bVoice[10] = (UINT8)(gpRmdInfo->dWtAdrTable[dWaveID] & 0xff);
			} else {
				sdRom = MaResMgr_GetDefWaveAddress((UINT8)(dWaveID & 0x7f));
				if (sdRom < 0) return (MASMW_ERROR);
				bVoice[9] = (UINT8)((sdRom >> 8) & 0xff);
				bVoice[10] = (UINT8)(sdRom & 0xff);
			}
			MaDevDrv_SendDirectRamData(dAdr, ENC_8BIT, &bVoice[2], 13);
			sdRet = MaSndDrv_SetVoice(gpRmdInfo->sdSeqID, dBk, dPg, dFlg, dKey, dAdr);
			gpRmdInfo->dRamOffset += 14;
			break;

		case 32:	/* 2-OP FM */
			if (dFlg != 1) return (MASMW_ERROR);
			if ((gpRmdInfo->dRamOffset + 16) > gpRmdInfo->dRamSize) return (MASMW_ERROR);
			Decode7Enc(&pbMsg[11], 20, bVoice, 17);
			dKey = bVoice[0];
			MaDevDrv_SendDirectRamData(dAdr, ENC_8BIT, &bVoice[1], 16);
			sdRet = MaSndDrv_SetVoice(gpRmdInfo->sdSeqID, dBk, dPg, dFlg, dKey, dAdr);
			gpRmdInfo->dRamOffset += 16;
			break;

		case 48:	/* 4-OP FM */
			if (dFlg != 1) return (MASMW_ERROR);
			if ((gpRmdInfo->dRamOffset + 31) > gpRmdInfo->dRamSize) return (MASMW_ERROR);
			Decode7Enc(&pbMsg[11], 36, bVoice, 31);
			dKey = bVoice[0];
			MaDevDrv_SendDirectRamData(dAdr, ENC_8BIT, &bVoice[1], 30);
			sdRet = MaSndDrv_SetVoice(gpRmdInfo->sdSeqID, dBk, dPg, dFlg, dKey, dAdr);
			gpRmdInfo->dRamOffset += 30;
			break;
		
		default:
			return (MASMW_ERROR);
		}
		break;

	case 0x03:		/* Set Wave */
		dAdr = gpRmdInfo->dRamBase + gpRmdInfo->dRamOffset;
		if (dSize < 10) return (MASMW_ERROR);
		dWsize = dSize - 9;
		dWsize = (dWsize >> 3) * 7 + (((dWsize & 0x07) == 0) ? 0 : ((dWsize & 0x07)-1));
		if ((gpRmdInfo->dRamOffset + dWsize) > gpRmdInfo->dRamSize) return (MASMW_ERROR);
		dPc = pbMsg[6];							/* wave ID */
		if (dPc > MAX_NUM_OF_WAVES) return (MASMW_ERROR);
		dFlg = (UINT8)(pbMsg[7] & 0x7f);
		sdRet = MaDevDrv_SendDirectRamData(dAdr, ENC_7BIT, &(pbMsg[8]), dSize - 9);
		gpRmdInfo->dRamOffset += ((dWsize + 1) >> 1) << 1;
		gpRmdInfo->dWtAdrTable[dPc] = dAdr;
		break;

	default:
		return (MASMW_SUCCESS);
	}

	return (sdRet);
}


/****************************************************************************
 *	MaRmdCnv_Control(SINT32 sdFileID, UINT32 dCtrlNum, void* pvPrm, void* pvExtArgs)
 *
 *	Description
 *		Special commands
 *	Param
 *		sdFileID		...	file ID
 *		dCtrlNum		...	Command ID
 *		pvPrm			...	param for the command
 *	Return
 *		0 : NoError, < 0 : Error
 ****************************************************************************/
SINT32	MaRmdCnv_Control(SINT32 sdFileID, UINT32 dCtrlNum, void* pvPrm, void* pvExtArgs)
{
	(void)pvExtArgs;

	MARMDCNV_DBGMSG(("MaRmdCnv_Control[%ld, %ld] \n", sdFileID, dCtrlNum));

	if ((sdFileID < 0) || (sdFileID != gpRmdInfo->sdFileID))
	{
		return (MASMW_ERROR);
	}

	switch(dCtrlNum)
	{
	case MASMW_SET_VOLUME :
		return (MaSndDrv_SetVolume(gpRmdInfo->sdSeqID, (UINT32)*((UINT8*)pvPrm), 7));

	case MASMW_SEND_MIDIMSG :
		if (gpRmdInfo->dOpend == 0) return (MASMW_ERROR);
		return (MaRmdCnv_SetShortMsg(sdFileID, *((UINT32*)pvPrm)));

	case MASMW_SEND_SYSEXMIDIMSG :
		if (gpRmdInfo->dOpend == 0) return (MASMW_ERROR);
		return (MaRmdCnv_SetLongMsg(sdFileID, ((PMASMW_MIDIMSG)pvPrm)->pbMsg, ((PMASMW_MIDIMSG)pvPrm)->dSize));

	case MASMW_GET_LENGTH :
		return (1000);					/* dummy length (1sec) */

	case MASMW_SET_REPEAT :
		return (MASMW_SUCCESS);			/* dummy func */

	case MASMW_GET_CONTROL_VAL:
		if (gpRmdInfo->dOpend == 0) return (MASMW_ERROR);
		switch (((PMASMW_GETCTL)pvPrm)->bControl)
		{
		case 0:	/* Master Volume */
			return (gpRmdInfo->dMasterVolume);
			
		case 1:	/* Channel Volume */
			if (((PMASMW_GETCTL)pvPrm)->bCh >= 16) return (MASMW_ERROR);
			return (gpRmdInfo->dChVolumeTable[((PMASMW_GETCTL)pvPrm)->bCh]);
		}
		return (MASMW_ERROR);
	
	case MASMW_SET_CB_INTERVAL: 
		if (gpRmdInfo->dOpend == 1) return (MASMW_ERROR);
		if ((*(UINT8*)pvPrm != 0) && (*(UINT8*)pvPrm != 20)) return (MASMW_ERROR);
		gpRmdInfo->dIntervalTime = (UINT32)*(UINT8*)pvPrm;
		return (MASMW_SUCCESS);
	}

	return (MASMW_ERROR);
}