mahvsw.c

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

/****************************************************************************
 *
 *		Copyright (C) 2003	YAMAHA CORPORATION. All rights reserved.
 *
 *		Module		: mahvsw.c
 *
 *		Description	: MA HV Sequence Wrapper
 *
 *		Version		: 2.0.0 	2003.07.14
 *
 ****************************************************************************/
#include "masndseq.h"
#include "masnddrv.h"

/****************************************************************************
 *	macro
 ****************************************************************************/
#define	MAHVSW_MAKEDWORD(a, b, c, d)	(UINT32)(((UINT32)(a) << 24) | \
						((UINT32)(b) << 16) | ((UINT32)(c) << 8) | (UINT32)(d))

/****************************************************************************
 *	define
 ****************************************************************************/
#define	MAHVSW_MAX_CALLBACK			(3)
#define	MAHVSW_MAX_VOICE			(16)
#define	MAHVSW_MAX_SCRIPT			(64)
#define	MAHVSW_NOTE_OFF				(191)
#define	MAHVSW_MIN_NOTE				(192)
#define	MAHVSW_MAX_NOTE				(MAHVSW_MIN_NOTE + MAHVSW_MAX_SCRIPT)
#define	MAHVSW_SIZE_OF_CHUNKHEADER	(8)

/****************************************************************************
 *	function
 ****************************************************************************/
static SINT32 CallBack_Dummy0(UINT8);
static SINT32 CallBack_Dummy1(UINT8);
static SINT32 CallBack_Dummy2(UINT8);

/****************************************************************************
 *	typedef
 ****************************************************************************/
typedef struct _tagMAHVSWHOOK
{
	SINT32	sdFuncId;
	SINT32	sdFileId;
	SINT32	(*pfnCallbackFunc)(UINT8);
} MAHVSWHOOK, *PMAHVSWHOOK;

typedef struct _tagMAHVSWDATA
{
	UINT8*	pbData;
	UINT32	dSize;
} MAHVSWDATA, *PMAHVSWDATA;

typedef struct _tagMAHVSWINFO
{
	SINT32		sdFuncId;						/*	*/
	SINT32		sdFileId;						/*	*/
	SINT32		sdHvFuncId;						/*	HV func ID				*/
	SINT32		sdHvFileId;						/*	HV file ID				*/
	UINT32		dVolume;						/*	volume		default:100	*/
	UINT32		dHvVolume;						/*	HV volume	default:127	*/
	SINT32		sdKey;							/*	key			default:0	*/
	SINT32		sdKeyCon;						/*	key control 0:disable 1:enable	*/
	MAHVSWHOOK	sHook[MAHVSW_MAX_CALLBACK];		/*	original callback function	*/
	MAHVSWDATA	sData[MAHVSW_MAX_SCRIPT];
	SINT32		sdDefaultHvLanguage;			/*	Default Language		*/
} MAHVSWINFO, *PMAHVSWINFO;

/****************************************************************************
 *	gloval values
 ****************************************************************************/
static MAHVSWINFO	gHvswInfo;

/****************************************************************************
 *	gloval tables
 ****************************************************************************/
static const SINT32 gsdHookId[MASMW_NUM_SRMCNV] = {
	-1, 0, -1, -1, -1, 1, 2, -1, -1, -1, -1, -1, -1
};

static SINT32	(*gpfnCallback[MAHVSW_MAX_CALLBACK])(UINT8) = {
	CallBack_Dummy0,
	CallBack_Dummy1,
	CallBack_Dummy2
};

/****************************************************************************
 *	IsHookFunc
 *
 *	Function:
 *			examine whether hook or not hook callback function.
 *	Argument:
 *			sdFuncId	... Function number.
 *	Return:
 *			>=0	success.
 *			<0	error.
 *
 ****************************************************************************/
static SINT32	IsHookFunc(SINT32 sdFuncId)
{
	if(sdFuncId < 0)					return (-1);
	if(MASMW_NUM_SRMCNV <= sdFuncId)	return (-1);

	return (gsdHookId[sdFuncId]);
}

/****************************************************************************
 *	MixVolume
 *
 *	Function:
 *			Mix master & HV volume.
 *	Argument:
 *			None
 *	Return:
 *			Mixed Volume(0..127)
 *
 ****************************************************************************/
static UINT32 MixVolume(void)
{
	UINT32	dVolume		= gHvswInfo.dVolume;
	UINT32	dHvVolume	= gHvswInfo.dHvVolume;

	if(dVolume > 127)	dVolume		= 127;
	if(dHvVolume > 127)	dHvVolume	= 127;

	return (MaSndDrv_Mix40LogVol(dVolume, dHvVolume));
}

/****************************************************************************
 *	GetLanguageType
 *
 *	Function:
 *			Get HV languate type.
 *	Argument:
 *			pbData	pointer to HV script.
 *			None	HV script size.
 *	Return:
 *			>=0	success.
 *			<0	error.
 *
 ****************************************************************************/
static SINT32 GetLanguageType(UINT8* pbData, UINT32 dSize)
{
	SINT32	sdHvType;

	if(pbData == NULL)	return (MASMW_ERROR_ARGUMENT);
	if(dSize < 4)		return (MASMW_ERROR_ARGUMENT);

	sdHvType = MASMW_HVTYPE_NONE;

	if(	(pbData[0] == 'H')	&&
		(pbData[1] == 'V')	&&
		(pbData[2] == '#')) {

		switch(pbData[3]) {
		case 'J' :
			sdHvType = MASMW_HVTYPE_JAPANESE;
			break;
		case 'K' :
			sdHvType = MASMW_HVTYPE_KOREAN;
			break;
		}
	}

	MASNDSEQ_DBGMSG(("Language Type %d \n", sdHvType));
	return (sdHvType);
}

/****************************************************************************
 *	GetFisrtLanguageType
 *
 *	Function:
 *			Get HV languate type.
 *	Argument:
 *			pbData	pointer to data buffer.
 *			None	data buffer size.
 *	Return:
 *			>=0	success.
 *			<0	error.
 *
 ****************************************************************************/
static SINT32 GetFirstLanguageType(UINT8* pbData, UINT32 dSize)
{
	SINT32	sdLangType;
	UINT32	dId;
	UINT32	dChunkId;
	UINT32	dChunkSize;

	if(pbData == NULL)								return (MASMW_ERROR_ARGUMENT);
	if(dSize < (UINT32)MAHVSW_SIZE_OF_CHUNKHEADER)	return (MASMW_ERROR_ARGUMENT);

	while(dSize >= (UINT32)MAHVSW_SIZE_OF_CHUNKHEADER) {
		dChunkId	= MAHVSW_MAKEDWORD(pbData[0], pbData[1], pbData[2], pbData[3]);
		dChunkSize	= MAHVSW_MAKEDWORD(pbData[4], pbData[5], pbData[6], pbData[7]);

		/*	Check chunk size	*/
		if(dSize < (UINT32)(MAHVSW_SIZE_OF_CHUNKHEADER + dChunkSize)) {
			return (MASMW_ERROR_CHUNK_SIZE);
		}

		pbData	+= (UINT32)MAHVSW_SIZE_OF_CHUNKHEADER;
		dSize	-= (UINT32)MAHVSW_SIZE_OF_CHUNKHEADER;

		if((dChunkId & 0xFFFFFF00) == MAHVSW_MAKEDWORD('M', 's', 'c', 0)) {
			dId = (dChunkId & 0x000000FF);
			if(dId < MAHVSW_MAX_SCRIPT) {
				sdLangType = GetLanguageType(pbData, dChunkSize);
				return (sdLangType);
			}
		}

		pbData	+= dChunkSize;
		dSize	-= dChunkSize;
	}

	return (MASMW_ERROR);
}

/****************************************************************************
 *	LoadHvScript
 *
 *	Function:
 *			Get HV scripts .
 *	Argument:
 *			pbData	pointer to data buffer.
 *			None	data buffer size.
 *	Return:
 *			>=0	success.
 *			<0	error.
 *
 ****************************************************************************/
static SINT32 LoadHvScript(UINT8* pbData, UINT32 dSize)
{
	UINT32	dId;
	UINT32	dChunkId;
	UINT32	dChunkSize;

	if(pbData == NULL)								return (MASMW_ERROR_ARGUMENT);
	if(dSize < (UINT32)MAHVSW_SIZE_OF_CHUNKHEADER)	return (MASMW_ERROR_ARGUMENT);

	while(dSize >= (UINT32)MAHVSW_SIZE_OF_CHUNKHEADER) {
		dChunkId	= MAHVSW_MAKEDWORD(pbData[0], pbData[1], pbData[2], pbData[3]);
		dChunkSize	= MAHVSW_MAKEDWORD(pbData[4], pbData[5], pbData[6], pbData[7]);

		/*	Check chunk size	*/
		if(dSize < (UINT32)(MAHVSW_SIZE_OF_CHUNKHEADER + dChunkSize)) {
			return (MASMW_ERROR_CHUNK_SIZE);
		}

		if((dChunkId & 0xFFFFFF00) == MAHVSW_MAKEDWORD('M', 's', 'c', 0)) {
			dId = (dChunkId & 0x000000FF);
			if(dId < MAHVSW_MAX_SCRIPT) {
				gHvswInfo.sData[dId].pbData	= (pbData + MAHVSW_SIZE_OF_CHUNKHEADER);
				gHvswInfo.sData[dId].dSize	= dChunkSize;
			}
		}

		pbData	+= dChunkSize + (UINT32)MAHVSW_SIZE_OF_CHUNKHEADER;
		dSize	-= dChunkSize + (UINT32)MAHVSW_SIZE_OF_CHUNKHEADER;
	}

	return (MASMW_SUCCESS);
}

/****************************************************************************
 *	MaHvsw_Initialize
 *
 *	Function:
 *			Initialize MAHVSWINFO structure.
 *	Argument:
 *			None
 *	Return:
 *			None
 *
 ****************************************************************************/
static void	MaHvsw_Initialize(void)
{
	UINT32			i;
	PMAHVSWDATA		pData;

	/*	for target format	*/
	gHvswInfo.sdFuncId		= -1;
	gHvswInfo.sdFileId		= -1;

	/*	for HV	*/
	gHvswInfo.sdHvFuncId	= -1;
	gHvswInfo.sdHvFileId	= -1;
	gHvswInfo.dVolume		= 100;
	gHvswInfo.dHvVolume		= 127;
	gHvswInfo.sdKey			= 0;
	gHvswInfo.sdKeyCon		= 0;

	/*	initialize HV script information	*/
	for(i = 0; i < MAHVSW_MAX_SCRIPT; i++) {
		pData = &(gHvswInfo.sData[i]);
		pData->pbData	= NULL;
		pData->dSize	= 0;
	}
}

/****************************************************************************
 *	MaHvsw_HvNoteOn
 *
 *	Function:
 *			Play HV.
 *	Argument:
 *			dId		HV Sequence Number(0..63)
 *			dEvent	Event Number
 *	Return:
 *			0	success.
 *			<0	error code.
 *
 ****************************************************************************/
static SINT32	MaHvsw_HvNoteOn(UINT32 dId)
{
	UINT8		bVolume;
	SINT8		sbKey;
	SINT32		sdRet;
	SINT32		sdFuncId = gHvswInfo.sdHvFuncId;
	SINT32		sdFileId;
	PMAHVSWDATA	psData = &(gHvswInfo.sData[dId]);

	if((sdFuncId < 0L) || (psData->pbData == NULL) || (psData->dSize == 0L)) {
		return (MASMW_ERROR);
	}
	/*	load HV script	*/
	sdRet = __MaSound_Load(sdFuncId, psData->pbData, psData->dSize, 1, NULL, NULL);
	if(sdRet < MASMW_SUCCESS) {
		return (sdRet);
	}
	/*	open HV script	*/
	sdFileId = sdRet;
	sdRet = __MaSound_Open(sdFuncId, sdFileId, 0, NULL);
	if(sdRet < MASMW_SUCCESS) {
		__MaSound_Unload(sdFuncId, sdFileId, NULL);
		return (sdRet);
	}
	/*	standby HV script	*/
	sdRet = __MaSound_Standby(sdFuncId, sdFileId, NULL);
	if(sdRet < MASMW_SUCCESS) {
		__MaSound_Close(sdFuncId, sdFileId, NULL);
		__MaSound_Unload(sdFuncId, sdFileId, NULL);
		return (sdRet);
	}
	/*	set volume	*/
	bVolume = (UINT8)MixVolume();
	__MaSound_Control(sdFuncId, sdFileId, MASMW_SET_VOLUME, &bVolume, NULL);
	/*	set key control	*/
	if(gHvswInfo.sdKeyCon) {
		/*	enable key control	*/
		sbKey = (SINT8)(gHvswInfo.sdKey);
		__MaSound_Control(sdFuncId, sdFileId, MASMW_SET_KEYCONTROL, &sbKey, NULL);
	}
	/*	start HV script	*/
	sdRet = __MaSound_Start(sdFuncId, sdFileId, 1, NULL);
	if(sdRet < MASMW_SUCCESS) {
		__MaSound_Close(sdFuncId, sdFileId, NULL);
		__MaSound_Unload(sdFuncId, sdFileId, NULL);
		return (sdRet);
	}

	/*	remember HVS file id	*/
	gHvswInfo.sdHvFileId = sdFileId;

	return (MASMW_SUCCESS);
}

/****************************************************************************
 *	MaHvsw_HvNoteOff
 *
 *	Function:
 *			Stop HV.
 *	Argument:
 *			none
 *	Return:
 *			0	success.
 *			<0	error code.
 *
 ****************************************************************************/
static SINT32	MaHvsw_HvNoteOff(void)
{
	SINT32	sdRet;
	SINT32	sdFuncId = gHvswInfo.sdHvFuncId;
	SINT32	sdFileId = gHvswInfo.sdHvFileId;

	/*	check func & file id	*/
	if((sdFuncId < 0L) || (sdFileId < 0L)) {
		return (MASMW_ERROR_ID);