mammfcnv.c

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

			if ((bSmafType == MMF_SMAF_TYPE_MA1) && (pbBuf[dIndex + 4] == 0x02))
				return MMF_MA2_VOICE_FOUND;
			if ((bSmafType == MMF_SMAF_TYPE_MA2) && (pbBuf[dIndex + 4] == 0x03))
				return MMF_MA2_VOICE_FOUND;
		}
		dIndex += (pbBuf[dIndex + 2] + 3);
	}

	return MMF_MA2_VOICE_NOTFOUND;
}


/*********************************************************************************
 *	get_flex2L
 *
 *	Description:
 *			get flex data (duration, gate time)
 *	Argument:
 *			pbBuf			pointer to data top
 *			dSize			size of data (remain)
 *			pdRead			pointer to size of flex data
 *	Return:
 *			>=0				success(flex data value)
 *			< 0				error code
 ********************************************************************************/
static SINT32			get_flex2L(
	UINT8*				pbBuf,
	UINT32				dSize,
	UINT32*				pbRead
)
{
	SINT32				sdTemp;

	if ((dSize < 1) || ((dSize < 2) && (pbBuf[0] >= 0x80)))
		return MMF_FUNC_ERROR;
	if (dSize >= 4) {
		sdTemp = pbBuf[0] + pbBuf[1] + pbBuf[2] + pbBuf[3];
		if (sdTemp == 0)
			return MMF_FUNC_ERROR;
	}
	if (pbBuf[0] >= 0x80) {
		sdTemp = (SINT32)( (((SINT32)(pbBuf[0] & 0x7F)) << 7) +
							((SINT32)(pbBuf[1] & 0x7F)) + 128 );
		*pbRead = 2;
	}
	else {
		sdTemp = (SINT32)(pbBuf[0] & 0x7F);
		*pbRead = 1;
	}
	return sdTemp;
}


/*********************************************************************************
 *	SeqData_Check2
 *
 *	Description:
 *			track chunk check (sequence massage)
 *	Argument:
 *			psTrack			pointer to track information structure
 *			bSmafType		SMAF type
 *	Return:
 *			0				success
 *			< 0				error code
 ********************************************************************************/
static SINT32			SeqData_Check2(
	PTRACKINFO			psTrack,
	UINT8				bSmafType
)
{
	UINT8*				pbBuf;
	UINT32				dSize, dIndex;
	SINT32				sdTemp;
	UINT32				dPast, dGate, dFlexSize;

	if (psTrack->pbMtsq == NULL) {
		return MMF_ERR_SLENGTH;
	}

	dPast	= 0;
	dGate	= 0;
	pbBuf	= psTrack->pbMtsq;
	dSize	= psTrack->dMtsqSize;
	dIndex	= 0;

/* scanning to EOS or stop point					*/
	while ( dSize > dIndex ) {
		if (psTrack->dStartPoint== dIndex)		/* start point	*/
			psTrack->dStartTick	= dPast;
		if (psTrack->dStopPoint == dIndex) {	/* stop point	*/
			psTrack->dStopTick	= dPast;
			break;
		}

		if (dSize >= dIndex + 4) {
			sdTemp=pbBuf[dIndex]+pbBuf[dIndex+1]+pbBuf[dIndex+2]+pbBuf[dIndex+3];
			if (sdTemp == 0) {					/* EOS			*/
				if (bSmafType == MMF_SMAF_TYPE_MA1)
					psTrack->dStopTick	= dPast + dGate;
				else
					psTrack->dStopTick	= dPast;
				break;
			}
		}

		sdTemp = get_flex2L(&pbBuf[dIndex], (dSize - dIndex), &dFlexSize);
		if (sdTemp < 0) {
			return MMF_ERR_CHUNK;
		}
		dPast += sdTemp;
		if (dPast >= MMF_PLAY_TIME_MAX) {
			return MMF_ERR_LLENGTH;
		}

		if ((UINT32)sdTemp >= dGate)			/* calculate remain of GT	*/
			dGate = 0;
		else
			dGate -= sdTemp;
		dIndex += dFlexSize;

		if (dSize < dIndex + 2) {
			return MMF_ERR_CHUNK;
		}

		switch (pbBuf[dIndex]) {
		case 0x00 :
			if ((pbBuf[dIndex + 1] & 0x30) != 0x30)
				dIndex += 2;
			else
				dIndex += 3;
			break;
		case 0xFF :
			switch (pbBuf[dIndex + 1]) {
			case 0x00 :
				dIndex += 2;
				break;
			case 0xF0 :
				if (dSize < dIndex + 3) {
					return MMF_ERR_CHUNK;
				}
				dIndex += (pbBuf[dIndex + 2] + 3);
				if (dSize < dIndex) {
					return MMF_ERR_CHUNK;
				}
				if (pbBuf[dIndex - 1] != 0xF7) {
					return MMF_ERR_CHUNK;
				}
				break;
			default :
				return MMF_ERR_CHUNK;
			}
			break;
		default :
			sdTemp = get_flex2L(&pbBuf[dIndex+1], (dSize - dIndex- 1), &dFlexSize);
			if (sdTemp < 0) {
				return MMF_ERR_CHUNK;
			}
			if (dGate < (UINT32)sdTemp)
				dGate = (UINT32)sdTemp;
			dIndex += (1 + dFlexSize);
			break;
		}
		if (dSize < dIndex) {
			return MMF_ERR_CHUNK;
		}
	}


	if (psTrack->dStartTick  == MMF_STSP_TIME_NULL) {
		if (psTrack->dStartPoint != MMF_STSP_OFFSET_NULL) {
			return MMF_ERR_CHUNK;
		}
		psTrack->dStartTick = 0;
	}

/* check start/stop point potision	*/
	if (psTrack->dStopTick  == MMF_STSP_TIME_NULL) {
		if ((psTrack->dStopPoint != MMF_STSP_OFFSET_NULL) &&
			(psTrack->dStopPoint != dIndex)) {
			return MMF_ERR_CHUNK;
		}
		if (bSmafType == MMF_SMAF_TYPE_MA1)
			psTrack->dStopTick	= dPast + dGate;
		else
			psTrack->dStopTick	= dPast;
	}

/* calculate playback time of this track	*/
	psTrack->dPlayTime = psTrack->dStopTick - psTrack->dStartTick;
	return MMF_FUNC_SUCCESS;
}


/*********************************************************************************
 *	TrackChunk_Check2
 *
 *	Description:
 *			MA-1/2 track chunk check 
 *	Argument:
 *			psLoad			pointer to load information structure
 *	Return:
 *			0				success
 *			< 0				error code
 ********************************************************************************/
static SINT32			TrackChunk_Check2(
	PLOADINFO			psLoad
)
{
	PTRACKINFO			psTrack;
	SINT32				sdResult;
	UINT8				i, fbVoice;

/* delete track information of MA-3/5	*/
		psLoad->sTrack_Info[5].pbMtr	= NULL;
		psLoad->sTrack_Info[5].dMtrSize	= 0;
		psLoad->sTrack_Info[6].pbMtr	= NULL;
		psLoad->sTrack_Info[6].dMtrSize	= 0;

/* fix SMAF Type												*/
	psLoad->dSmafType = MMF_SMAF_TYPE_MA1;
	for (i = 1; i < 5; i++) {
		if (psLoad->sTrack_Info[i].pbMtr != NULL) {
			psLoad->dSmafType = MMF_SMAF_TYPE_MA2;
			break;
		}
	}
	if (psLoad->sTrack_Info[MMF_ATR_TRACK_NO].pbMtr != NULL)
		psLoad->dSmafType = MMF_SMAF_TYPE_MA2;

	if (psLoad->dSmafType == MMF_SMAF_TYPE_MA1) {	/* MA-1			*/
		if (psLoad->sTrack_Info[0].pbMtr == NULL) {
			return MMF_ERR_SLENGTH;
		}
		psTrack = &(psLoad->sTrack_Info[0]);
		if (psTrack->dMtrSize <= MMF_MINIMUM_TRACKSIZE2) {
			return MMF_ERR_CHUNK;
		}
		sdResult = MTR_Check(psTrack, MMF_SMAF_TYPE_MA1);
		if (sdResult != MMF_FUNC_SUCCESS) {
			return sdResult;
		}
		MspI_Check(psTrack, &(psLoad->sPhrase_Info[0]));
		sdResult = ST_SP_Check(psTrack);
		if (sdResult != MMF_FUNC_SUCCESS) {
			return sdResult;
		}
		sdResult = Mtsu_Check2(psTrack, MMF_SMAF_TYPE_MA1);
		if (sdResult != MMF_MA2_VOICE_FOUND) {
			return MMF_ERR_CHUNK;
		}
		sdResult = SeqData_Check2(psTrack, MMF_SMAF_TYPE_MA1);
		if (sdResult != MMF_FUNC_SUCCESS) {
			return sdResult;
		}
		psLoad->dPlayTime	= psTrack->dPlayTime;
		psLoad->dStartTime	= psTrack->dStartTick;
		psLoad->dTimeBase	= psTrack->dTimeBase;
		return MMF_FUNC_SUCCESS;
	}
	else {											/* MA-2			*/
		psLoad->sTrack_Info[0].pbMtr	= NULL;
		psLoad->sTrack_Info[0].dMtrSize	= 0;

		for (i = 1; i < 5; i++) {
			psTrack = &(psLoad->sTrack_Info[i]);
			if (psTrack->pbMtr == NULL)
				continue;
			if (psTrack->dMtrSize <= MMF_MINIMUM_TRACKSIZE2) {
				return MMF_ERR_CHUNK;
			}
			sdResult = MTR_Check(psTrack, MMF_SMAF_TYPE_MA2);
			if (sdResult != MMF_FUNC_SUCCESS) {
				return sdResult;
			}
			MspI_Check(psTrack, &(psLoad->sPhrase_Info[0]));
			sdResult = ST_SP_Check(psTrack);
			if (sdResult != MMF_FUNC_SUCCESS) {
				return sdResult;
			}
			sdResult = SeqData_Check2(psTrack, MMF_SMAF_TYPE_MA2);
			if (sdResult != MMF_FUNC_SUCCESS) {
				return sdResult;
			}
			psLoad->dPlayTime	= psTrack->dPlayTime;
			psLoad->dStartTime	= psTrack->dStartTick;
			psLoad->dTimeBase	= psTrack->dTimeBase;
		}
		if (psLoad->sTrack_Info[MMF_ATR_TRACK_NO].pbMtr != NULL) {
			psTrack = &(psLoad->sTrack_Info[MMF_ATR_TRACK_NO]);

			if (psTrack->dMtrSize <= MMF_MINIMUM_TRACKSIZE2) {
				return MMF_ERR_CHUNK;
			}
			sdResult = ATR_Check(psTrack);
			if (sdResult != MMF_FUNC_SUCCESS) {
				return sdResult;
			}
			MspI_Check(psTrack, &(psLoad->sPhrase_Info[0]));
			sdResult = ST_SP_Check(psTrack);
			if (sdResult != MMF_FUNC_SUCCESS) {
				return sdResult;
			}
			sdResult = SeqData_Check2(psTrack, MMF_SMAF_TYPE_MA2);
			if (sdResult != MMF_FUNC_SUCCESS) {
				return sdResult;
			}
			psLoad->dPlayTime	= psTrack->dPlayTime;
			psLoad->dStartTime	= psTrack->dStartTick;
			psLoad->dTimeBase	= psTrack->dTimeBase;
		}

/* totaling of track information	*/
		for (i = 1; i < MMF_MAX_TRACK_NUM; i++) {
			psTrack = &(psLoad->sTrack_Info[i]);
			if (psTrack->pbMtr == NULL)
				continue;

			if (psLoad->dPlayTime   < psTrack->dPlayTime)
				psLoad->dPlayTime   = psTrack->dPlayTime;
			if (psLoad->dTimeBase  != psTrack->dTimeBase) {
				return MMF_ERR_CHUNK;
			}
			if (psLoad->dStartTime != psTrack->dStartTick) {
				return MMF_ERR_CHUNK;
			}
			if (Mtsu_Check2(psTrack, MMF_SMAF_TYPE_MA2) == MMF_FUNC_SUCCESS)
				fbVoice = MMF_MA2_VOICE_FOUND;
		}

		fbVoice = MMF_MA2_VOICE_FOUND;
		for (i = 1; i < 5; i++) {
			psTrack = &(psLoad->sTrack_Info[i]);
			if (psTrack->pbMtr == NULL)
				continue;
			if (Mtsu_Check2(psTrack, MMF_SMAF_TYPE_MA2) == MMF_MA2_VOICE_FOUND) {
				fbVoice = MMF_MA2_VOICE_FOUND;
				break;
			}
			else
				fbVoice = MMF_MA2_VOICE_NOTFOUND;
		}

		if (fbVoice == MMF_MA2_VOICE_NOTFOUND) {
			return MMF_ERR_CHUNK;
		}
	}
	return MMF_FUNC_SUCCESS;
}


/*********************************************************************************
 *	Decode_GetbitL
 *
 *	Description:
 *			get 1 bit with error check
 *	Argument:
 *			psHuf			pointer to huffman information structure
 *	Return:
 *			read data
 ********************************************************************************/
static UINT8			Decode_GetbitL(
	PHUFFMANINFO		psHuf
)
{
	if (--psHuf->sbBitC < 0) {
		if (psHuf->dReadSize >= psHuf->dMtsqSize)
			return 0;
		psHuf->sbBitC	= 7;
		psHuf->bByte	= *(psHuf->psBuffer++);
		psHuf->dReadSize ++;
	}
	return (UINT8)(psHuf->bByte & abBitMaskTable1[psHuf->sbBitC]);
}


/*********************************************************************************
 *	Decode_Getbits
 *
 *	Description:
 *			get 8 bit
 *	Argument:
 *			psHuf			pointer to huffman information structure
 *	Return:
 *			read data
 ********************************************************************************/
static UINT8			Decode_Getbits(
	PHUFFMANINFO		psHuf
)
{
	UINT16				wTemp;
	UINT8				bData1, bData2;

	if (psHuf->dReadSize >= psHuf->dMtsqSize)
		return 0;
	bData1	= psHuf->bByte;
	bData2	= *(psHuf->psBuffer++);
	psHuf->bByte = bData2;
	psHuf->dReadSize ++;
	wTemp = (UINT16)((((UINT16)bData1) << 8) + ((UINT16)bData2));
	return (UINT8)((wTemp & awBitMaskTable2[psHuf->sbBitC]) >> psHuf->sbBitC);
}


/*********************************************************************************
 *	Decode_tree
 *
 *	Description:
 *			make MA-3 huffman decode tree
 *	Argument:
 *			psHuf			pointer to huffman information structure
 *	Return:
 *			!0				success(sequence data size)
 *			0				error
 ********************************************************************************/
static SINT32			Decode_tree(
	PHUFFMANINFO		psHuf
)
{
	UINT32				dNode, dEmpty, dIndex, i;
	SINT16				*pswLeft, *pswRight, *pswPNode;
	UINT8				bTemp;

    if (Decode_GetbitL(psHuf)) {
		if (psHuf->dReadSize >= psHuf->dMtsqSize)
			return MMF_HUFFMAN_TREE_FAILURE;

		pswLeft	= &(psHuf->swLeft[256]);
		pswRight= &(psHuf->swRight[256]);
		pswPNode= &(psHuf->swRight[0]);
		for (i = 0; i < 256; i++) {
			pswLeft[i]	= -1;
			pswRight[i]	= -1;
			pswPNode[i]	= 0;
		}
		dNode	= 2;
		dEmpty	= 1;
		dIndex	= 0;
	}
	else
		return MMF_HUFFMAN_TREE_FAILURE;

	while (dNode != 0) {
		if ((dEmpty >= 256) || (dNode >= 257))
			return MMF_HUFFMAN_TREE_FAILURE;

		bTemp = Decode_GetbitL(psHuf);
		if (psHuf->dReadSize >= psHuf->dMtsqSize)
			return MMF_HUFFMAN_TREE_FAILURE;

		if (bTemp) {
			dNode ++;
			if (pswLeft[dIndex] == -1)
				pswLeft[dIndex]	= (SINT16)(dEmpty + 256);
			else
				pswRight[dIndex]= (SINT16)(dEmpty + 256);