mammfcnv.c

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

			pswPNode[dEmpty] = (SINT16)dIndex;
			dIndex = dEmpty;
			dEmpty ++;
		}
		else {
			dNode --;
			bTemp = Decode_Getbits(psHuf);
			if (psHuf->dReadSize >= psHuf->dMtsqSize)
				return MMF_HUFFMAN_TREE_FAILURE;

			if (pswLeft[dIndex] == -1)
				pswLeft[dIndex]	= (SINT16)bTemp;
			else {
				pswRight[dIndex]= (SINT16)bTemp;
				while ((pswRight[dIndex] != -1) && (dIndex != 0))
					dIndex = (UINT32)pswPNode[dIndex];
			}
		}
	}

	for (i = 0; i < 256; i++) {
		if (pswLeft[i]	== -1)
			pswLeft[i]	= 0;
		if (pswRight[i]	== -1)
			pswRight[i]	= 0;
	}
	return MMF_HUFFMAN_TREE_SUCCESS;
}


/*********************************************************************************
 *	Decode_init
 *
 *	Description:
 *			make MA-3 huffman decode tree
 *	Argument:
 *			psHuf			pointer to huffman information structure
 *	Return:
 *			!0				success(sequence data size)
 *			0				error
 ********************************************************************************/
static UINT32			Decode_init(
	PHUFFMANINFO		psHuf
)
{
	UINT32				dSeqSize;

	if (psHuf->dMtsqSize <= 5) {
		return MMF_HUFFMAN_TREE_FAILURE;
	}

	dSeqSize = get_4byte(psHuf->psBuffer);
	psHuf->psBuffer += 4;
	psHuf->dReadSize = 4;
	psHuf->sbBitC = 0;
	psHuf->bByte  = 0;
	if (Decode_tree(psHuf) == MMF_HUFFMAN_TREE_FAILURE)
		return MMF_HUFFMAN_TREE_FAILURE;
	else
		return dSeqSize;
}


/*********************************************************************************
 *	decode_byte3L
 *
 *	Description:
 *			get 1 byte (from compressed data)
 *	Argument:
 *			psHuf			pointer to huffman information structure
 *	Return:
 *			UINT8			success(read data)
 *			0				error code
 ********************************************************************************/
static UINT8			decode_byte3L(
	PHUFFMANINFO		psHuf
)
{
	UINT32				bData, bIndex;

	bIndex = 256;
	while (bIndex >= 256) {
		if (--psHuf->sbBitC < 0) {
			psHuf->dReadSize ++;
			if (psHuf->dReadSize > psHuf->dMtsqSize)
				return 0;
			psHuf->sbBitC	= 7;
			psHuf->bByte	= *(psHuf->psBuffer++);
		}
		bData = (UINT8)(psHuf->bByte & abBitMaskTable1[psHuf->sbBitC]);
		if (bData)
			bIndex = psHuf->swRight[bIndex];
		else
			bIndex = psHuf->swLeft[bIndex];
	}
	return (UINT8)bIndex;
}


/*********************************************************************************
 *	decode_byte3
 *
 *	Description:
 *			get 1 byte (from compressed data)
 *	Argument:
 *			nothing
 *	Return:
 *			UINT8			success(read data)
 ********************************************************************************/
static UINT8			decode_byte3( void )
{
	PHUFFMANINFO		psHuf;
	UINT32				bData, bIndex;

	psHuf = &(gsSmaf_Info.sLoad_Info[1].sHuffman_Info);
	psHuf->dReadSize ++;
	bIndex = 256;
	while (bIndex >= 256) {
		if (--psHuf->sbBitC < 0) {
			psHuf->sbBitC	= 7;
			psHuf->bByte	= *(psHuf->psBuffer++);
		}
		bData = (UINT8)(psHuf->bByte & abBitMaskTable1[psHuf->sbBitC]);
		if (bData)
			bIndex = psHuf->swRight[bIndex];
		else
			bIndex = psHuf->swLeft[bIndex];
	}
	return (UINT8)bIndex;
}


/*********************************************************************************
 *	get_byte3L
 *
 *	Description:
 *			get 1 byte (from normal data)
 *	Argument:
 *			psHuf			pointer to huffman information structure
 *	Return:
 *			UNIT8			success(read data)
 *			0				error code
 ********************************************************************************/
static UINT8			get_byte3L(
	PHUFFMANINFO		psHuf
)
{
	psHuf->dReadSize ++;
	if (psHuf->dReadSize > psHuf->dMtsqSize) {
		return 0;
	}
	return *(psHuf->psBuffer++);
}


/*********************************************************************************
 *	get_byte3
 *
 *	Description:
 *			get 1 byte (from normal data)
 *	Argument:
 *			nothing
 *	Return:
 *			UINT8			success(read data)
 ********************************************************************************/
static UINT8			get_byte3( void )
{
	PHUFFMANINFO		psHuf;

	psHuf = &(gsSmaf_Info.sLoad_Info[1].sHuffman_Info);
	psHuf->dReadSize ++;
	return *(psHuf->psBuffer++);
}


/*********************************************************************************
 *	get_flex3L
 *
 *	Description:
 *			MA-3 sequence data check
 *	Argument:
 *			psLoad			pointer to load information structure
 *			pdRead			pointer to size of flex data
 *	Return:
 *			>=0				success
 *			< 0				error code
 ********************************************************************************/
static SINT32			get_flex3L(
	PLOADINFO			psLoad,
	UINT32*				pdRead
)
{
	UINT32				dTemp, dRead;
	UINT8				bTemp;

	dRead = 1;
	bTemp = psLoad->pfnGetByte( &(psLoad->sHuffman_Info) );
	dTemp = (UINT32)(bTemp & 0x7F);
	while (bTemp & 0x80) {
		if (dRead >= 4)
			return MMF_FUNC_ERROR;
		dRead ++;
		bTemp = psLoad->pfnGetByte( &(psLoad->sHuffman_Info) );
		dTemp = (dTemp << 7) + (UINT32)(bTemp & 0x7F);
	}
	if (dTemp >= MMF_PLAY_TIME_MAX)
		return MMF_FUNC_ERROR;
	*pdRead = dRead;
	return (SINT32)dTemp;
}


/*********************************************************************************
 *	get_flex3
 *
 *	Description:
 *			MA-3 sequence data check
 *	Argument:
 *			nothing
 *	Return:
 *			UINT32			flex value
 ********************************************************************************/
static UINT32			get_flex3( void )
{
	UINT32				dTemp;
	UINT8				bTemp;

	bTemp = gsSmaf_Info.sPlay_Info.pfnGetByte();
	dTemp = (UINT32)(bTemp & 0x7F);
	while (bTemp & 0x80) {
		bTemp = gsSmaf_Info.sPlay_Info.pfnGetByte();
		dTemp = (dTemp << 7) + (UINT32)(bTemp & 0x7F);
	}
	return dTemp;
}


/*********************************************************************************
 *	get_flex5L
 *
 *	Description:
 *			MA-3 sequence data check
 *	Argument:
 *			psLoad			pointer to load information structure
 *			pdRead			pointer to size of flex data
 *	Return:
 *			>=0				success(flex data value)
 *			< 0				error
 ********************************************************************************/
static SINT32			get_flex5L(
	UINT8*				pbBuf,
	UINT32*				pdRead
)
{
	UINT32				dTemp, dRead;
	UINT8				bTemp;

	dRead = 1;
	bTemp = pbBuf[0];
	dTemp = (UINT32)(bTemp & 0x7F);
	while (bTemp & 0x80) {
		if (dRead >= 4)
			return MMF_FUNC_ERROR;
		dRead ++;
		bTemp = pbBuf[dRead - 1];
		dTemp = (dTemp << 7) + (UINT32)(bTemp & 0x7F);
	}
	if (dTemp >= MMF_PLAY_TIME_MAX)
		return MMF_FUNC_ERROR;
	*pdRead = dRead;
	return (SINT32)dTemp;
}


/*********************************************************************************
 *	SeqData_Check3
 *
 *	Description:
 *			MA-3 sequence data check
 *	Argument:
 *			psLoad			pointer to load information structure
 *			bSmafType		SMAF type
 *	Return:
 *			0				success
 *			< 0				error code
 ********************************************************************************/
static SINT32			SeqData_Check3(
	PLOADINFO			psLoad,
	UINT8				bSmafType
)
{
	PTRACKINFO			psTrk;
	PPHRASEINFO			psPhr;
	PHUFFMANINFO		psHuf;
	UINT32				dIndex, fdPhrase, dSize, dPast, dGate, dReadSize, i;
	UINT32				dStartTick, dStopTick;
	SINT32				sdTemp;
	UINT8				bTemp;

	if (bSmafType == MMF_SMAF_TYPE_MA3) {			/* MA-3		*/
		psTrk		= &(psLoad->sTrack_Info[5]);
		dStartTick	= MMF_STSP_TIME_NULL;
		dStopTick	= MMF_STSP_TIME_NULL;
	}
	else {											/* MA-5		*/
		psTrk		= &(psLoad->sTrack_Info[6]);
		dStartTick	= psTrk->dStartTick;
		dStopTick	= psTrk->dStopTick;
		psTrk->dStartTick	= MMF_STSP_TIME_NULL;
		psTrk->dStopTick	= MMF_STSP_TIME_NULL;
	}

	psPhr	= &(psLoad->sPhrase_Info[0]);
	psHuf	= &(psLoad->sHuffman_Info);
	fdPhrase= 0;
	dIndex	= 0;
	dPast	= 0;
	dGate	= 0;
	dSize	= psHuf->dSeqSize;

	if (psHuf->dSeqSize == 0) {
		return MMF_ERR_SLENGTH;
	}

	for (i = 0; i < MMF_MAX_PHRASE_INFO; i++) {
		if (psPhr[i].dStartPoint != MMF_STSP_OFFSET_NULL)
			fdPhrase = 1;
	}

/* scanning sequence data to EOS or stop point	*/
	while (dSize >= dIndex) {

		if (psTrk->dStartPoint	== dIndex)
			psTrk->dStartTick	=  dPast;
		if (psTrk->dStopPoint	== dIndex)			/* stop point		*/
			psTrk->dStopTick	=  dPast;
		if (fdPhrase) {
			for (i = 0; i < MMF_MAX_PHRASE_INFO; i++) {
				if (psPhr[i].dStartPoint== dIndex)
					psPhr[i].dStartTick	=  dPast;
				if (psPhr[i].dStopPoint	== dIndex)
					psPhr[i].dStopTick	=  dPast;
			}
		}

		if ((psTrk->dStopTick != MMF_STSP_TIME_NULL) || (dSize == dIndex))
			break;

		sdTemp = get_flex3L(psLoad, &dReadSize);	/* Duration			*/
		if (sdTemp < 0) {
			return MMF_ERR_CHUNK;
		}
		dPast	+= (UINT32)sdTemp;
		if (dPast >= MMF_PLAY_TIME_MAX) {
			return MMF_ERR_LLENGTH;
		}

		if ((UINT32)sdTemp >= dGate)
			dGate = 0;
		else
			dGate -= (UINT32)sdTemp;
		dIndex += dReadSize;

		bTemp = psLoad->pfnGetByte(psHuf);
		dIndex ++;

		switch (bTemp & 0xF0) {
		case 0x90 :
			psLoad->pfnGetByte(psHuf);
			dIndex ++;
		case 0x80 :
			psLoad->pfnGetByte(psHuf);
			dIndex ++;
			sdTemp = get_flex3L(psLoad, &dReadSize);
			if (sdTemp < 0) {
				return MMF_ERR_CHUNK;
			}
			dIndex += dReadSize;
			if ((UINT32)sdTemp > dGate)
				dGate = sdTemp;
			break;
		case 0xA0 :
		case 0xB0 :
		case 0xE0 :
			bTemp = psLoad->pfnGetByte(psHuf);
			dIndex ++;
		case 0xC0 :
		case 0xD0 :
			bTemp = psLoad->pfnGetByte(psHuf);
			dIndex ++;
			break;
		default :
			switch (bTemp) {
			case 0xF0 :
				sdTemp = get_flex3L(psLoad, &dReadSize);
				if (sdTemp < 0) {
					return MMF_ERR_CHUNK;
				}
				for (i = 0; i < (UINT32)sdTemp; i++)
					bTemp = psLoad->pfnGetByte(psHuf);
				if (bTemp != 0xF7) {
					return MMF_ERR_CHUNK;
				}
				dIndex += (UINT32)sdTemp + dReadSize;
				break;
			case 0xFF :
				bTemp = psLoad->pfnGetByte(psHuf);
				dIndex ++;
				switch (bTemp) {
				case 0x00 :
					break;
				case 0x2F :
					bTemp = psLoad->pfnGetByte(psHuf);
					dIndex ++;
					if (bTemp != 0x00) {
						return MMF_ERR_CHUNK;
					}
					dGate = 0;
					psTrk->dStopTick = dPast;
					dIndex = dSize;
					break;
				default :
					return MMF_ERR_CHUNK;
				}
				break;
			default :
				return MMF_ERR_CHUNK;
			}
			break;
		}
		if ((dSize < dIndex) || (psHuf->dReadSize > psHuf->dMtsqSize)) {
			return MMF_ERR_CHUNK;
		}
	}

	if (bSmafType == MMF_SMAF_TYPE_MA3) {			/* MA-3		*/
/* check start point				*/
		if (psTrk->dStartTick == MMF_STSP_TIME_NULL) {
			if (psTrk->dStartPoint != MMF_STSP_OFFSET_NULL) {
				return MMF_ERR_CHUNK;
			}
			psTrk->dStartPoint	= 0;
			psTrk->dStartTick	= 0;
		}
/* check stop point				*/
		if (psTrk->dStopTick == MMF_STSP_TIME_NULL) {
			if (psTrk->dStopPoint != MMF_STSP_OFFSET_NULL) {
				return MMF_ERR_CHUNK;
			}
			psTrk->dStopPoint	= dSize;
			psTrk->dStopTick	= dPast + dGate;
		}
/* adjust phrase information	*/
		for (i = 0; i < MMF_MAX_PHRASE_INFO; i++) {
			if (psPhr[i].dStartPoint <= psTrk->dStartPoint)