malib.c

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

		/*	Update	*/
		pbData	+= dChunkSize;
		dRemain	-= (UINT32)(dChunkSize + MALIB_SIZE_OF_CHUNKHEADER);
	}

	return (MASMW_ERROR_CHUNK);
}

/****************************************************************************
 *	malib_smafphrase_checker
 *
 *	Function:
 *			Check SMAF/Phrase data.
 *	Argument:
 *			pbData		Pointer to SMAF/Phrase data
 *			dSize		size of data
 *			pvInfo		pointer to MALIBPHRINFO
 *	Return:
 *			0		success.
 *			< 0		error code.
 *
 ****************************************************************************/
SINT32	malib_smafphrase_checker(UINT8* pbData, UINT32 dSize, void* pvInfo)
{
	SINT32			sdRet;
	MALIBPHRINFO	sInfo;
	PMALIBPHRINFO	pPi = (PMALIBPHRINFO)pvInfo;

	if(pbData == NULL)	return (MASMW_ERROR_ARGUMENT);
	if(dSize == 0L)		return (MASMW_ERROR_ARGUMENT);

	/*	call from music API	*/
	if(pPi == NULL) {
		pPi = &sInfo;
		pPi->dErrChk = 1L;	/*	enable error check	*/
	}

	/*	check data format	*/
	sdRet = SmafPhrChecker(pbData, dSize, pPi);
	if(sdRet < MASMW_SUCCESS) {
		return (sdRet);
	}

	/*	tick to ms	*/
	return (SINT32)(pPi->dPlayTime * MALIB_PHRASE_TIMEBASE);
}

/*********************************************************************************
 *	malib_NextChunk
 *
 *	Description:
 *			chunk information
 *	Argument:
 *			pbFile			pointer to data
 *			dFsize			size of data(remain)
 *			dState			chunk search status
 *			pdChunkID		pointer to write chunk id space
 *			pdChunkNo		pointer to write chunk no space
 *	Return:
 *			>=0				success(chunk size)
 *			< 0				error code
 ********************************************************************************/
SINT32					malib_NextChunk(
	UINT8*				pbFile,
	UINT32				dSize,
	UINT32				dState,
	UINT32*				pdChunkID,
	UINT32*				pdChunkNo
)
{
	UINT32				dChunkID, dChunkSize;

	if (dSize < MALIB_SIZE_OF_CHUNKHEADER)
		return MALIB_CHUNK_SIZE_ERROR;

	dChunkID	= MALIB_MAKEDWORD(pbFile[0], pbFile[1], pbFile[2], pbFile[3]);
	dChunkSize	= MALIB_MAKEDWORD(pbFile[4], pbFile[5], pbFile[6], pbFile[7]);

	switch (dChunkID) {
	case MALIB_CHUNKID_MMMD :
		*pdChunkID = MALIB_CHUNKCODE_MMMD;
		if (dState != MALIB_CHUNK_PHASE_MMMD)
			return MALIB_CHUNK_ID_ERROR;
		break;
	case MALIB_CHUNKID_CNTI :
		*pdChunkID = MALIB_CHUNKCODE_CNTI;
		if (dState != MALIB_CHUNK_PHASE_CNTI)
			return MALIB_CHUNK_ID_ERROR;
		break;
	case MALIB_CHUNKID_OPDA :
		*pdChunkID = MALIB_CHUNKCODE_OPDA;
		if (dState != MALIB_CHUNK_PHASE_MMMDSUB)
			return MALIB_CHUNK_ID_ERROR;
		break;
	case MALIB_CHUNKID_MSPI :
		*pdChunkID = MALIB_CHUNKCODE_MSPI;
		if (dState != MALIB_CHUNK_PHASE_MTRSUB)
			return MALIB_CHUNK_ID_ERROR;
		break;
	case MALIB_CHUNKID_MTSU :
		*pdChunkID = MALIB_CHUNKCODE_MTSU;
		if (dState != MALIB_CHUNK_PHASE_MTRSUB)
			return MALIB_CHUNK_ID_ERROR;
		break;
	case MALIB_CHUNKID_MTSQ :
		*pdChunkID = MALIB_CHUNKCODE_MTSQ;
		if (dState != MALIB_CHUNK_PHASE_MTRSUB)
			return MALIB_CHUNK_ID_ERROR;
		break;
	case MALIB_CHUNKID_MTSP :
		*pdChunkID = MALIB_CHUNKCODE_MTSP;
		if (dState != MALIB_CHUNK_PHASE_MTRSUB)
			return MALIB_CHUNK_ID_ERROR;
		break;
	case MALIB_CHUNKID_ASPI :
		*pdChunkID = MALIB_CHUNKCODE_ASPI;
		if (dState != MALIB_CHUNK_PHASE_ATRSUB)
			return MALIB_CHUNK_ID_ERROR;
		break;
	case MALIB_CHUNKID_ATSU :
		*pdChunkID = MALIB_CHUNKCODE_ATSU;
		if (dState != MALIB_CHUNK_PHASE_ATRSUB)
			return MALIB_CHUNK_ID_ERROR;
		break;
	case MALIB_CHUNKID_ATSQ :
		*pdChunkID = MALIB_CHUNKCODE_ATSQ;
		if (dState != MALIB_CHUNK_PHASE_ATRSUB)
			return MALIB_CHUNK_ID_ERROR;
		break;

	case MALIB_CHUNKID_MTHV :
		*pdChunkID = MALIB_CHUNKCODE_MTHV;
		if (dState != MALIB_CHUNK_PHASE_MTRSUB)
			return MALIB_CHUNK_ID_ERROR;
		break;
	case MALIB_CHUNKID_MHVS :
		*pdChunkID = MALIB_CHUNKCODE_MHVS;
		if (dState != MALIB_CHUNK_PHASE_MTHVSUB)
			return MALIB_CHUNK_ID_ERROR;
		break;
	case MALIB_CHUNKID_MHSC :
		*pdChunkID = MALIB_CHUNKCODE_MHSC;
		if (dState != MALIB_CHUNK_PHASE_MTHVSUB)
			return MALIB_CHUNK_ID_ERROR;
		break;

	default :
		*pdChunkNo = (UINT8)(dChunkID & 0x000000FF);
		switch (dChunkID & 0xFFFFFF00) {
		case MALIB_CHUNKID_MTR :
			*pdChunkID = MALIB_CHUNKCODE_MTR;
			if (dState != MALIB_CHUNK_PHASE_MMMDSUB)
				return MALIB_CHUNK_ID_ERROR;
			break;
		case MALIB_CHUNKID_ATR :
			*pdChunkID = MALIB_CHUNKCODE_ATR;
			if (dState != MALIB_CHUNK_PHASE_MMMDSUB)
				return MALIB_CHUNK_ID_ERROR;
			break;

		case MALIB_CHUNKID_DCH :
			*pdChunkID = MALIB_CHUNKCODE_DCH;
			if (dState != MALIB_CHUNK_PHASE_OPDASUB)
				return MALIB_CHUNK_ID_ERROR;
			break;
		case MALIB_CHUNKID_M5P :
			*pdChunkID = MALIB_CHUNKCODE_M5P;
			if (dState != MALIB_CHUNK_PHASE_OPDASUB)
				return MALIB_CHUNK_ID_ERROR;
			break;

		case MALIB_CHUNKID_MWA :
			*pdChunkID = MALIB_CHUNKCODE_MWA;
			if (dState != MALIB_CHUNK_PHASE_MTSPSUB)
				return MALIB_CHUNK_ID_ERROR;
			break;

		case MALIB_CHUNKID_AWA :
			*pdChunkID = MALIB_CHUNKCODE_AWA;
			if (dState != MALIB_CHUNK_PHASE_ATRSUB)
				return MALIB_CHUNK_ID_ERROR;
			break;

		case MALIB_CHUNKID_HVP :
			*pdChunkID = MALIB_CHUNKCODE_HVP;
			if (dState != MALIB_CHUNK_PHASE_MTHVSUB)
				return MALIB_CHUNK_ID_ERROR;
			break;

		default :
			*pdChunkID = MALIB_CHUNKCODE_UNKNOWN;
			break;
		}
		break;
	}

	if (dChunkSize > (dSize - MALIB_SIZE_OF_CHUNKHEADER))
		return MALIB_CHUNK_SIZE_ERROR;
	else
		return (SINT32)dChunkSize;
}

/****************************************************************************
 *	GetWaveInfo_2
 *
 *	Function:
 *			Get data Info from the file
 *	Argument:
 *			pbFile		pointer to the SMAF/Audio data.
 *			dFileSize	size of data.
 *			pAi			pointer to the MALIBAUDINFO structure.
 *	Return:
 *			0		success.
 *			< 0		error.
 *
 ****************************************************************************/
static SINT32	GetWaveInfo_2(UINT8* pbFile, UINT32 dSize, PMALIBAUDINFO pAi)
{
	UINT32	dFmt;
	UINT32	dData;
	UINT8*	pbWave;
	UINT32	dChunkID, dChunkNo;
	UINT32	dIndex;
	UINT32	dFs;
	SINT32	sdChunkSize;
	SINT32	sdSizeOfWave;

	dData = (UINT32)pbFile[2];
	if		(dData == 0x10)		dFs = 4000;		/* Mono, ADPCM, 4KHz	*/
	else if	(dData == 0x11)		dFs = 8000;		/* Mono, ADPCM, 8KHz	*/
	else						return (MASMW_ERROR_CHUNK);	/* Error	*/

	dData = (UINT32)pbFile[3];
	if (dData == 0x00)			dFmt = 0x01;	/* 4bit ADPCM			*/
	else						return (MASMW_ERROR_CHUNK);	/* Error	*/

	dIndex			= 6L;
	pbWave			= NULL;
	sdSizeOfWave	= 0L;
	while(dSize > (dIndex + MALIB_SIZE_OF_CHUNKHEADER)) {
		sdChunkSize = malib_NextChunk(&pbFile[dIndex], (dSize - dIndex),
				MALIB_CHUNK_PHASE_ATRSUB, &dChunkID, &dChunkNo);
		if(sdChunkSize < 0) {
			MAAUDCNV_DBGMSG(("GetDataInfo/Found Error Chunk/\n"));
			return (MASMW_ERROR_CHUNK);
		}
		if ((dChunkID == MALIB_CHUNKCODE_AWA) && (pbWave == NULL)) {
			sdSizeOfWave	= sdChunkSize;
			pbWave			= &(pbFile[dIndex + MALIB_SIZE_OF_CHUNKHEADER]);
		}
		dIndex	+= (UINT32)(sdChunkSize + MALIB_SIZE_OF_CHUNKHEADER);
	}

	if ((UINT32)sdSizeOfWave <= (dFs / 100))	return MASMW_ERROR_SHORT_LENGTH;

	pAi->pbSource		= pbWave;
	pAi->dSizeOfSource	= (UINT32)sdSizeOfWave;
	pAi->dFs			= dFs;
	pAi->dFmt			= dFmt;

	MAAUDCNV_DBGMSG(("MaAudCnv : Fs =  %ld[Hz]\n", pAi->dFs));
	MAAUDCNV_DBGMSG(("MaAudCnv : pData = %08lX\n", pAi->pbSource));
	MAAUDCNV_DBGMSG(("MaAudCnv : Size = %ld[bytes]\n", pAi->dSizeOfSource));

	return (MASMW_SUCCESS);
}

/****************************************************************************
 *	GetWaveInfo_3
 *
 *	Function:
 *			Get data Info from the file
 *	Argument:
 *			pbFile		pointer to the SMAF/Audio data.
 *			dFileSize	size of data.
 *			pAi			pointer to the MALIBAUDINFO structure.
 *	Return:
 *			0		success.
 *			< 0		error.
 *
 ****************************************************************************/
static SINT32	GetWaveInfo_3(UINT8* pbFile, UINT32 dSize, PMALIBAUDINFO pAi)
{
	UINT32	dFmt;
	UINT32	dChunkID, dChunkNo;
	UINT32	dIndex;
	UINT32	dFs;
	SINT32	sdChunkSize;
	UINT8*	pMtsp;
	UINT32	dMtspSize;

	dIndex		= 20;
	dFmt		= 0xFFL;
	pMtsp		= NULL;
	dMtspSize	= 0;

	while(dSize > dIndex + MALIB_SIZE_OF_CHUNKHEADER) {
		sdChunkSize = malib_NextChunk(&(pbFile[dIndex]), (dSize - dIndex),
				MALIB_CHUNK_PHASE_MTRSUB, &dChunkID, &dChunkNo);
		if(sdChunkSize < 0L) {
			MAAUDCNV_DBGMSG(("GetDataInfo/Found Error Chunk/\n"));
			return (MASMW_ERROR_CHUNK);
		}
		if((dChunkID == MALIB_CHUNKCODE_MTSP) && (pMtsp == NULL)) {
			pMtsp		= &(pbFile[dIndex + MALIB_SIZE_OF_CHUNKHEADER]);
			dMtspSize	= sdChunkSize;
		}
		dIndex	+= (UINT32)(sdChunkSize + MALIB_SIZE_OF_CHUNKHEADER);
	}

	if (pMtsp == NULL)		return MASMW_ERROR_SHORT_LENGTH;

	dIndex		= 0;
	while(dMtspSize > dIndex + MALIB_SIZE_OF_CHUNKHEADER) {
		sdChunkSize = malib_NextChunk(&(pMtsp[dIndex]), (dMtspSize - dIndex),
				MALIB_CHUNK_PHASE_MTSPSUB, &dChunkID, &dChunkNo);
		if(sdChunkSize < 4L) {
			MAAUDCNV_DBGMSG(("GetDataInfo/Found Error Chunk/\n"));
			return (MASMW_ERROR_CHUNK);
		}
		if((dChunkID != MALIB_CHUNKCODE_MWA)) {
			dIndex	+= (UINT32)(sdChunkSize + MALIB_SIZE_OF_CHUNKHEADER);
			continue;
		}
		sdChunkSize	-= 3L;
		dFs			=	((UINT32)pMtsp[dIndex + 9] << 8);
		dFs			+=	(UINT32)pMtsp[dIndex + 10];
		if(dFs < MALIB_MIN_STREAM_FS)  return (MASMW_ERROR_CHUNK);

		switch(pMtsp[dIndex + 8]) {
		case 0x01:
			if(dFs > MALIB_MAX_8BIT_MONO_FS)
				return (MASMW_ERROR_CHUNK);
			if((UINT32)sdChunkSize <= (dFs / 50))
				return (MASMW_ERROR_SHORT_LENGTH);
			MAAUDCNV_DBGMSG(("MaAudCnv : 8bit 2's comp mono PCM\n"));
			dFmt = 0x03L;
			break;

		case 0x11:
			if(dFs > MALIB_MAX_8BIT_MONO_FS)
				return (MASMW_ERROR_CHUNK);
			if((UINT32)sdChunkSize <= (dFs / 50))
				return (MASMW_ERROR_SHORT_LENGTH);
			MAAUDCNV_DBGMSG(("MaAudCnv : 8bit offset mono PCM\n"));
			dFmt = 0x02L;
			break;

		case 0x20:
			if(dFs > MALIB_MAX_4BIT_MONO_FS)
				return (MASMW_ERROR_CHUNK);
			if((UINT32)sdChunkSize <= (dFs / 100))
				return (MASMW_ERROR_SHORT_LENGTH);
			MAAUDCNV_DBGMSG(("MaAudCnv : YAMAHA 4bit mono ADPCM\n"));
			dFmt = 0x01L;
			break;

		default:
			MAAUDCNV_DBGMSG(("GetDataInfo/ Wave format error\n"));
			return (MASMW_ERROR_CHUNK);
		}

		pAi->pbSource		= &(pMtsp[dIndex + 11]);
		pAi->dSizeOfSource	= (UINT32)sdChunkSize;
		pAi->dFs			= dFs;
		pAi->dFmt			= dFmt;

		MAAUDCNV_DBGMSG(("MaAudCnv : Fs =  %ld[Hz]\n", pAi->dFs));
		MAAUDCNV_DBGMSG(("MaAudCnv : pData = %08lX\n", pAi->pbSource));
		MAAUDCNV_DBGMSG(("MaAudCnv : Size = %ld[bytes]\n", pAi->dSizeOfSource));
		break;
	}

	if(dFmt == 0xFFL) return (MASMW_ERROR_SHORT_LENGTH);
	return (MASMW_SUCCESS);
}

/****************************************************************************
 *	GetWaveInfo_5
 *
 *	Function:
 *			Get data Info from the file
 *	Argument:
 *			pbFile		pointer to the SMAF/Audio data.
 *			dFileSize	size of data.
 *			pAi			pointer to the MALIBAUDINFO structure.
 *	Return:
 *			0		success.
 *			< 0		error.
 *
 ****************************************************************************/
static SINT32	GetWaveInfo_5(UINT8* pbFile, UINT32 dSize, PMALIBAUDINFO pAi)
{
	UINT32	dFmt;
	UINT32	dChunkID, dChunkNo;
	UINT32	dIndex;
	UINT32	dFs;
	SINT32	sdChunkSize;
	UINT8*	pMtsp;
	UINT32	dMtspSize;

	dIndex		= 20;
	dFmt		= 0xFFL;
	pMtsp		= NULL;
	dMtspSize	= 0;

	while(dSize > dIndex + MALIB_SIZE_OF_CHUNKHEADER) {
		sdChunkSize = malib_NextChunk(&(pbFile[dIndex]), (dSize - dIndex),
				MALIB_CHUNK_PHASE_MTRSUB, &dChunkID, &dChunkNo);
		if(sdChunkSize < 0L) {
			MAAUDCNV_DBGMSG(("GetDataInfo/Found Error Chunk/\n"));
			return (MASMW_ERROR_CHUNK);
		}
		if((dChunkID == MALIB_CHUNKCODE_MTSP) && (pMtsp == NULL)) {
			pMtsp		= &(pbFile[dIndex + MALIB_SIZE_OF_CHUNKHEADER]);
			dMtspSize	= sdChunkSize;
		}
		dIndex	+= (UINT32)(sdChunkSize + MALIB_SIZE_OF_CHUNKHEADER);
	}

	if (pMtsp == NULL)		return MASMW_ERROR_SHORT_LENGTH;

	dIndex	= 0;
	while(dMtspSize > dIndex + MALIB_SIZE_OF_CHUNKHEADER) {
		sdChunkSize = malib_NextChunk(&(pMtsp[dIndex]), (dMtspSize - dIndex),
				MALIB_CHUNK_PHASE_MTSPSUB, &dChunkID, &dChunkNo);
		if(sdChunkSize < 4L) {
			MAAUDCNV_DBGMSG(("GetDataInfo/Found Error Chunk/\n"));
			return (MASMW_ERROR_CHUNK);
		}
		if((dChunkID != MALIB_CHUNKCODE_MWA)) {
			dIndex	+= (UINT32)(sdChunkSize + MALIB_SIZE_OF_CHUNKHEADER);
			continue;
		}

		sdChunkSize	-= 3L;
		dFs			=	((UINT32)pMtsp[dIndex + 9] << 8);
		dFs			+=	(UINT32)pMtsp[dIndex + 10];
		if(dFs < MALIB_MIN_STREAM_FS)  return (MASMW_ERROR_CHUNK);

		switch(pMtsp[dIndex + 8]) {
		case 0x01:
			if(dFs > MALIB_MAX_8BIT_MONO_FS)
				return (MASMW_ERROR_CHUNK);
			if((UINT32)sdChunkSize <= (dFs / 50))
				return (MASMW_ERROR_SHORT_LENGTH);
			MAAUDCNV_DBGMSG(("MaAudCnv : 8bit 2's comp mono PCM\n"));
			dFmt = 0x03L;
			break;

		case 0x11:
			if(dFs > MALIB_MAX_8BIT_MONO_FS)
				return (MASMW_ERROR_CHUNK);
			if((UINT32)sdChunkSize <= (dFs / 50))
				return (MASMW_ERROR_SHORT_LENGTH);
			MAAUDCNV_DBGMSG(("MaAudCnv : 8bit offset mono PCM\n"));
			dFmt = 0x02L;
			break;

		case 0x20:
			if(dFs > MALIB_MAX_4BIT_MONO_FS)
				return (MASMW_ERROR_CHUNK);
			if((UINT32)sdChunkSize <= (dFs / 100))
				return (MASMW_ERROR_SHORT_LENGTH);
			MAAUDCNV_DBGMSG(("MaAudCnv : YAMAHA 4bit mono ADPCM\n"));
			dFmt = 0x01L;
			break;

		case 0x81:
			if(dFs > MALIB_MAX_8BIT_STEREO_FS)
				return (MASMW_ERROR_CHUNK);
			if((UINT32)sdChunkSize <= (dFs / 25))
				return (MASMW_ERROR_SHORT_LENGTH);
			MAAUDCNV_DBGMSG(("MaAudCnv : 8bit 2's comp stereo PCM\n"));
			dFmt = 0x83L;
			break;

		case 0x91:
			if(dFs > MALIB_MAX_8BIT_STEREO_FS)
				return (MASMW_ERROR_CHUNK);
			if((UINT32)sdChunkSize <= (dFs / 25))
				return (MASMW_ERROR_SHORT_LENGTH);
			MAAUDCNV_DBGMSG(("MaAudCnv : 8bit offset stereo PCM\n"));
			dFmt = 0x82L;
			break;