malib.c

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

	pPhrChk->dwSize = dwSize;

	return (0L);
}


/*=============================================================================
//	Function Name	:	UINT32	PhrChk_GetCntiInfoChunkBody(PPHRCHECK pPhrChk)
//
//	Description		:	Check SMAF/Phrase Contents info chunk body
//
//	Argument		:	pPhrChk	...	Pointer to the checking result
//
//	Return			:	0 NoError
//						!0 Error
//
=============================================================================*/
static UINT32			PhrChk_GetCntiInfoChunkBody(
	MALIB_PPHRCHECK		pPhrChk
)
{
	UINT32			dwSize;
	MALIB_PPHRINFO	pPi;

	pPi = pPhrChk->pPhrInfo;
	pPi->bCntiClass		= _get1b(&(pPhrChk->pbBuffer));		/*	Contents Class		*/
	pPi->bCntiType		= _get1b(&(pPhrChk->pbBuffer));		/*	Contents Type		*/
	pPi->bCodeType		= _get1b(&(pPhrChk->pbBuffer));		/*	Contents Code Type	*/
	pPi->bCopyStatus	= _get1b(&(pPhrChk->pbBuffer));		/*	Copy Status			*/
	pPi->bCopyCount		= _get1b(&(pPhrChk->pbBuffer));		/*	Copy Count			*/

	/*	Contents Class		*/
	if(pPhrChk->bMode & MALIB_CHKMODE_ENABLE)
	{
		if  (pPi->bCntiClass != MALIB_CNTI_CLASS_YAMAHA) {
			pPhrChk->wErrStatus |= MALIB_PHRASE_DATA_CLASS;
			return (1L);
		}

		/*	Contents Type		*/
		if  (pPi->bCntiType != MALIB_CNTI_TYPE_PHRASE) {
			pPhrChk->wErrStatus |= MALIB_PHRASE_DATA_TYPE;
			return (1L);
		}
	}

	/*	Option				*/
	pPhrChk->pPhrInfo->pbCntiOption = pPhrChk->pbBuffer;

	/*	skip	*/
	dwSize = pPhrChk->pPhrInfo->dwCntiOptionSize;
	pPhrChk->pbBuffer += dwSize;

	/*	update	*/
	pPhrChk->dwSize	 -= (UINT32)(dwSize + MALIB_SIZE_OF_MIN_CNTI + MALIB_SIZE_OF_CHUNKHEADER);
	return	(0L);
}


/*=============================================================================
//	Function Name	:	UINT32	PhrChk_CntiInfoChunkCheck(PPHRCHECK pPhrChk)
//
//	Description		:	Check SMAF/Phrase Contents info chunk
//
//	Argument		:	pPhrChk	...	Pointer to the checking result
//
//	Return			:	0 NoError
//						!0 Error
//
=============================================================================*/
static UINT32			PhrChk_CntiInfoChunkCheck(
	MALIB_PPHRCHECK		pPhrChk
)
{
	UINT32		dwSize;
	static UINT8 bChunkName[5] = "CNTI";

	/*	Check Size							*/
	if(pPhrChk->dwSize < (UINT32)(MALIB_SIZE_OF_CHUNKHEADER + MALIB_SIZE_OF_MIN_CNTI + MALIB_SIZE_OF_CRC)) {
		pPhrChk->wErrStatus |= MALIB_PHRASE_DATA_SIZE;
		return (1L);
	}

	/*	Check Contents Info ID				*/
	if(PhrChk_CompareID(bChunkName, pPhrChk->pbBuffer, 0xFFFFFFFF) != 0L) {
		pPhrChk->wErrStatus |= MALIB_PHRASE_DATA_CHUNK;
		return (1L);
	}
	pPhrChk->pbBuffer += 4L;

	/*	Get Chunk and  Size					*/
	dwSize	= _get4b(&(pPhrChk->pbBuffer));

	/*	Check Size							*/
	if(dwSize < (UINT32)MALIB_SIZE_OF_MIN_CNTI) {
		pPhrChk->wErrStatus |= MALIB_PHRASE_DATA_SIZE;
		return (1L);
	}

	/*	Check Size							*/
	if(pPhrChk->dwSize < (UINT32)(MALIB_SIZE_OF_CHUNKHEADER + dwSize + MALIB_SIZE_OF_CRC)) {
		pPhrChk->wErrStatus |= MALIB_PHRASE_DATA_SIZE;
		return (1L);
	}

	/*	Contents Info Chunk body			*/
	pPhrChk->pPhrInfo->dwCntiOptionSize = (UINT16)(dwSize - MALIB_SIZE_OF_MIN_CNTI);
	if(PhrChk_GetCntiInfoChunkBody(pPhrChk) != 0L) {
		return (1L);
	}

	return (0L);
}


/*=============================================================================
//	Function Name	:	UINT32	PhrChk_OptionDataChunkCheck(PPHRCHECK pPhrChk)
//
//	Description		:	Check SMAF/Phrase Option data chunk
//
//	Argument		:	pPhrChk	...	Pointer to the checking result
//
//	Return			:	0 NoError
//						!0 Error
//
=============================================================================*/
static UINT32			PhrChk_OptionDataChunkCheck(
	MALIB_PPHRCHECK		pPhrChk
)
{
	UINT32		dwSize;
	static UINT8 bChunkName[5] = "OPDA";

	/*	Check Size							*/
	if(pPhrChk->dwSize < (UINT32)(MALIB_SIZE_OF_CHUNKHEADER + MALIB_SIZE_OF_CRC)) {
		pPhrChk->wErrStatus |= MALIB_PHRASE_DATA_SIZE;
		return (1L);
	}

	/*	Check Option Data Chunk				*/
	if(PhrChk_CompareID(bChunkName, pPhrChk->pbBuffer, 0xFFFFFFFF) != 0L) {
		return (0L);
	}

	/*	Get Chunk and Size					*/
	pPhrChk->pbBuffer += 4L;
	dwSize	= _get4b(&(pPhrChk->pbBuffer));

	/*	Check Size							*/
	if(pPhrChk->dwSize < (UINT32)(MALIB_SIZE_OF_CHUNKHEADER + dwSize + MALIB_SIZE_OF_CRC)) {
		pPhrChk->wErrStatus |= MALIB_PHRASE_DATA_SIZE;
		return (1L);
	}

	pPhrChk->pPhrInfo->pbOptionChunk	= pPhrChk->pbBuffer;
	pPhrChk->pPhrInfo->dwOptionDataSize	= dwSize;

	/*	update	*/
	pPhrChk->pbBuffer += dwSize;
	pPhrChk->dwSize	 -= (UINT32)(dwSize + MALIB_SIZE_OF_CHUNKHEADER);
	return	(0L);
}


/*=============================================================================
//	Function Name	:	UINT32	PhrChk_InfoChunkBody(PPHRCHECK pPhrChk)
//
//	Description		:	Check SMAF/Phrase Info chunk body
//
//	Argument		:	pPhrChk	...	Pointer to the checking result
//
//	Return			:	0 NoError
//						!0 Error
//
=============================================================================*/
static UINT32			PhrChk_InfoChunkBody(
	MALIB_PPHRCHECK		pPhrChk
)
{
	UINT32			dwSize;
	MALIB_PPHRINFO	pPi = pPhrChk->pPhrInfo;

	/*	Get Size								*/
	dwSize = _get4b(&(pPhrChk->pbPhrase));

	/*	Check Size								*/
	if(pPhrChk->dwPhraseSize < (UINT32)(MALIB_SIZE_OF_CHUNKHEADER + dwSize))
	{
		pPhrChk->wErrStatus |= MALIB_PHRASE_DATA_SIZE;
		return (1L);
	}

	/*	Remember position and size				*/
	pPi->pbInfoChunk		= pPhrChk->pbPhrase;
	pPi->dwInfoChunkSize	= dwSize;

	/*	Update	*/
	pPhrChk->pbPhrase		+= dwSize;
	pPhrChk->dwPhraseSize	-= (UINT32)(dwSize + MALIB_SIZE_OF_CHUNKHEADER);
	return (0L);
}


/*=============================================================================
//	Function Name	:	UINT32	PhrChk_DefaultVoiceChunkBody(PPHRCHECK pPhrChk)
//
//	Description		:	Check SMAF/Phrase Voice chunk
//
//	Argument		:	dwNumofVoice	...	Registering Voice number
//						pPhrChk			...	Pointer to the checking result
//
//	Return			:	0 NoError
//						!0 Error
//
=============================================================================*/
static UINT32			PhrChk_DefaultVoiceChunkBody(
	UINT32				dwNumofVoice,
	MALIB_PPHRCHECK		pPhrChk
)
{
	UINT8			bProgNo;
	UINT8*			pParam;
	UINT32			dwSize;
	MALIB_PVOCINFO	pVi;

	if(dwNumofVoice >= MALIB_MAX_PHRASE_VOICES)		return(1L);

	pVi = &(pPhrChk->pPhrInfo->VocInfo[dwNumofVoice]);

	/*	Get Size								*/
	dwSize = _get4b(&(pPhrChk->pbVoice));

	/*	Check Size								*/
	if(pPhrChk->dwVoiceSize < (UINT32)(MALIB_SIZE_OF_CHUNKHEADER + dwSize))
	{
		pPhrChk->wErrStatus |= MALIB_PHRASE_DATA_SIZE;
		return (1L);
	}

	pParam = pPhrChk->pbVoice;

	if (dwSize >= 1L) {
		/*	set default voice						*/
		bProgNo = pParam[0];
		pVi->bBankNo = 0;		/*	means default voice	*/
		pVi->bProgNo = (UINT8)(bProgNo & 0x7F);
		pVi->bType	 = MALIB_VOICE_TYPE_MA3;
		pVi->bSize	 = 0;
		pVi->pbVoice = NULL;
	}
	else {
		pVi->bBankNo = 0;
		pVi->bProgNo = 0;
	}

	/*	Update	*/
	pPhrChk->pbVoice += dwSize;
	pPhrChk->dwVoiceSize -= (UINT32)(dwSize + MALIB_SIZE_OF_CHUNKHEADER);
	return (0L);
}


/*=============================================================================
//	Function Name	:	UINT32	PhrChk_ExtendVoiceChunkBody(PPHRCHECK pPhrChk)
//
//	Description		:	Check SMAF/Phrase Extend Voice chunk body
//
//	Argument		:	dwNumofVoice	...	Registering Voice number
//						pPhrChk			...	Pointer to the checking result
//
//	Return			:	0 NoError
//						!0 Error
//
=============================================================================*/
static UINT32			PhrChk_ExtendVoiceChunkBody(
	UINT32				dwNumofVoice,
	MALIB_PPHRCHECK		pPhrChk
)
{
	UINT8			bSize;
	UINT8			bVoiceType;
	UINT8*			pParam;
	UINT32			dwSize;
	MALIB_PVOCINFO	pVi;

	if(dwNumofVoice >= MALIB_MAX_PHRASE_VOICES)		return(1L);

	pVi = &(pPhrChk->pPhrInfo->VocInfo[dwNumofVoice]);

	/*	Get Size								*/
	dwSize = _get4b(&(pPhrChk->pbVoice));

	/*	Check Size								*/
	if(pPhrChk->dwVoiceSize < (UINT32)(MALIB_SIZE_OF_CHUNKHEADER + dwSize))
	{
		pPhrChk->wErrStatus |= MALIB_PHRASE_DATA_SIZE;
		return (1L);
	}

	bVoiceType	= MALIB_VOICE_TYPE_UNKNOWN;
	pParam		= pPhrChk->pbVoice;
	bSize = 0;

	if (dwSize >= 21L) {	/* MA-2 2op Voice(Shortest voice parameter) */
		/*	-------------------------- Get voice ----------------------------	*/
		bSize		= pParam[2];

		/*	Check Size								*/
		if(dwSize < (UINT32)(bSize + 3))
		{
			pPhrChk->wErrStatus |= MALIB_PHRASE_DATA_SIZE;
			return (1L);
		}

		/*	MA-2 FM wave format setting */
		if(	(pParam[0] == 0xFF)		&&
			(pParam[1] == 0xF0)		&&
			(pParam[3] == 0x43)		&&
			(pParam[4] == 0x03))
		{
			if(	((bSize == 18) || (bSize == 28)) && (pParam[bSize + 2] == 0xF7)) {
				bSize		-= 3;
				pParam		+= 5;
				bVoiceType = MALIB_VOICE_TYPE_MA2;
			}
		}
		/*	MA-3 FM wave format setting	*/
		else if((pParam[0] == 0xFF)		&&
				(pParam[1] == 0xF0)		&&
				(pParam[3] == 0x43)		&&
				(pParam[4] == 0x04)		&&
				(pParam[5] == 0x01))
		{
			if(	((bSize == 20) || (bSize == 34)) && (pParam[bSize + 2] == 0xF7)) {
				bSize		-= 4;
				pParam		+= 6;
				bVoiceType	= MALIB_VOICE_TYPE_MA3;
			}
		}
	}

	if(bVoiceType == MALIB_VOICE_TYPE_UNKNOWN) {
		/*	Set ProgNo = 0 as default vioce		*/
		pVi->bBankNo = 0;
		pVi->bProgNo = 0;
	} else {
		/*	extend voice setting				*/
		pVi->bBankNo = (UINT8)(pPhrChk->pPhrInfo->bPhrNum+1); /* means extend voice */
		pVi->bProgNo = (UINT8)(dwNumofVoice);
		pVi->bType	 = bVoiceType;
		pVi->bSize	 = bSize;
		pVi->pbVoice = pParam;
	}

	/*	Update	*/
	pPhrChk->pbVoice	 += dwSize;
	pPhrChk->dwVoiceSize -= (UINT32)(dwSize + MALIB_SIZE_OF_CHUNKHEADER);
	return (0L);
}


/*=============================================================================
//	Function Name	:	UINT32	PhrChk_VoiceChunkCheck(PPHRCHECK pPhrChk)
//
//	Description		:	Check SMAF/Phrase voice chunk
//
//	Argument		:	pPhrChk	...	Pointer to the checking result
//
//	Return			:	0 NoError
//						!0 Error
//
=============================================================================*/
static UINT32			PhrChk_VoiceChunkCheck(
	MALIB_PPHRCHECK		pPhrChk
)
{
	UINT32			i;
	UINT32			dwSize;
	UINT32			dwSkip;
	UINT32			dwNumofVoice;
	MALIB_PPHRINFO	pPi = pPhrChk->pPhrInfo;
	MALIB_PVOCINFO	pVi;
	static UINT8	bChunkName0[5] = "DEVO";
	static UINT8	bChunkName1[5] = "EXVO";

	/*	Get Size								*/
	dwSize = _get4b(&(pPhrChk->pbPhrase));

	/*	Check Size								*/
	if(pPhrChk->dwPhraseSize < (UINT32)(MALIB_SIZE_OF_CHUNKHEADER + dwSize))
	{
		pPhrChk->wErrStatus |= MALIB_PHRASE_DATA_SIZE;
		return (1L);
	}

	/*	Remember position and size				*/
	pPhrChk->pbVoice		= pPhrChk->pbPhrase;
	pPhrChk->dwVoiceSize	= dwSize;
	pPi->pbVoiceChunk		= pPhrChk->pbPhrase;
	pPi->dwVoiceChunkSize	= dwSize;

	/*	Get Voice Parameter						*/
	dwNumofVoice = 0L;
	while(pPhrChk->dwVoiceSize > (UINT32)(MALIB_SIZE_OF_CHUNKHEADER))
	{
		/**/
		if(	(dwNumofVoice < MALIB_MAX_PHRASE_VOICES)	&&
			(PhrChk_CompareID(bChunkName0, pPhrChk->pbVoice, 0xFFFFFFFF) == 0L))
		{
			pPhrChk->pbVoice += 4L;
			if(PhrChk_DefaultVoiceChunkBody(dwNumofVoice, pPhrChk) != 0L) {
				return (1L);
			}
			dwNumofVoice++;
		}
		/**/
		else if((dwNumofVoice < MALIB_MAX_PHRASE_VOICES)	&&
				(PhrChk_CompareID(bChunkName1, pPhrChk->pbVoice, 0xFFFFFFFF) == 0L))
		{
			pPhrChk->pbVoice += 4L;
			if(PhrChk_ExtendVoiceChunkBody(dwNumofVoice, pPhrChk) != 0L) {
				return (1L);
			}
			dwNumofVoice++;
		}
		/*	other chunk!!						*/
		else
		{
			/*	Skip Chunk						*/
			pPhrChk->pbVoice += 4L;
			dwSkip = _get4b(&(pPhrChk->pbVoice));

			/*	Check Size			*/
			if(pPhrChk->dwVoiceSize < (UINT32)(MALIB_SIZE_OF_CHUNKHEADER + dwSkip))
			{
				pPhrChk->wErrStatus |= MALIB_PHRASE_DATA_SIZE;
				return (1L);
			}