mamidcnv.c

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

typedef struct _tagTrack
{
	UINT8		bSmfCmd;				/* CMD @ now                      */
	UINT32		dwSize;					/* [byte] 0 measns nothing in it. */
	UINT8*		pBase;					/* NULL measns nothing in it.     */
	UINT32		dwOffset;				/* offset byte                    */
	SINT32		dwTicks;				/*                                */
} TRACKINFO, *PTRACKINFO;

typedef struct _MAMIDCNV_INFO
{
	UINT32	dwTimeResolution;	/*                                               */
	UINT8	bFmMode;			/*                                               */
	UINT8*	pTitle;				/*                                               */
	UINT32	dwSizeTitle;		/*                                               */
	UINT8*	pCopyright;			/*                                               */
	UINT32	dwSizeCopyright;	/*                                               */
	UINT8	bSetupBar;			/* 0:No, 1:Yes                                   */
	UINT32	dwStart;			/* Index after SetupBar                          */
	UINT32	dwTotalTicks;		/* Total ticks                                   */
	SINT32	dwDataEndTime;		/* (22.10)[ms]                                   */
	SINT32	dwDelta;			/* (22.10)[ms]                                   */
	UINT8	bNumOfTracks;		/*                                               */
	UINT8	bSmfFormat;			/*                                               */
	TRACKINFO	iTrack[MAX_SMF_TRACKS];
} MAMIDCNV_INFO, *PMAMIDCNV_INFO;

static SINT32			gSeqID;								/* Sequence ID             */
static SINT32			gFileID;							/* File ID                 */
static UINT8			gEnable;							/* 0:disabel               */
static UINT8			gNumOfLoaded;						/*                         */
static UINT8			gSetup;								/* 1: Just after seek      */

static UINT8			gbMaxGain;							/* MaxGain                 */
static UINT8			gbMasterVolume;						/* MsaterVolume            */
static UINT8			gNumOfTracks;						/* Number of tracks        */

static UINT32			gRamBase;							/*                         */
static UINT32			gRamOffset;							/*                         */
static UINT32			gRamSize;							/*                         */

static UINT32			gWtWaveAdr[128];					/*                         */

static UINT8			gSetupBar;							/* 0:No, 1:Yes             */
static MAMIDCNV_DEFINFO	gChDef[MAMIDCNV_MAX_CHANNELS];		/*                         */

static UINT8			gHoldMsgs;							/* Number of messages in Q */
static UINT8			gHoldPtrR;							/* Pointer for Read        */
static MAMIDCNV_PACKET	gMsgBuffer[MAX_SMF_MESSAGES];		/* Message Q               */

static UINT32			gSmfTimeResolution;					/*                         */
static MAMIDCNV_INFO	gSmfInfo[2];						/*                         */

static UINT32			gSmfTotalTicks;						/* Total Ticks             */
static UINT32			gSmfStart;							/* Index after SetupBar    */
static SINT32			gSmfDataEndTime;					/* (22.10)[ms]             */

static SINT32			gSmfCurrentTicks;					/* Ticks @ now             */
static SINT32			gSmfCurrentTime;					/* (22.10)[ms]             */
static SINT32			gSmfEndTime;						/* (22.10)[ms]             */
static SINT32			gSmfDelta;							/* (22.10)[ms]             */
static SINT32			gLastMsgTime;						/* (22.10)[ms]             */

static UINT16			gwBank[MAMIDCNV_MAX_CHANNELS];		/*                         */
static UINT16			gwRealBank[MAMIDCNV_MAX_CHANNELS];
static UINT16			gwRPN[MAMIDCNV_MAX_CHANNELS];		/*                         */
static UINT8			gbLEDFlag[MAMIDCNV_MAX_CHANNELS];	/* bit0: for LED, bit1: for Motor */
static SINT32			gdwNumOnLED;						
static SINT32			gdwNumOnMotor;						
static UINT8			gKEYCON[MAMIDCNV_MAX_CHANNELS];		/* 0:Melady, 1:OFF, 2:ON   */
static UINT32			gNumOn[MAMIDCNV_MAX_CHANNELS];		/* Number of KeyOn         */
static UINT8			gEndFlag;							/*                         */
static SINT32			gSeekTime;							/* [ms]                    */
static UINT32			gTrackEndFlag;						/*                         */

static UINT8			gbMipMute[MAMIDCNV_MAX_CHANNELS];	/* Mute switch (1:mute)    */

static UINT32			gdwMelodyVoice4op[128];
static UINT32			gdwDrumVoice4op[128];
static UINT32			gdwSEVoice[128];
static UINT32			gdwExMelodyVoiceWT[128];
static UINT32			gdwProg[MAMIDCNV_MAX_CHANNELS];
static UINT8			gFMMode;
/*=============================================================================
//	Function Name	:	void	ResetTimeInfo(PMAMIDCNV_INFO pI, UINT32* pdwEndFlag)
//
//	Description		:	Reset time info
//
//	Argument		:	pI			... pointer to the setup storage
//						pdwEndFlag	... pointer to the Endflag
//
//	Return			: none
=============================================================================*/
static void	ResetTimeInfo(PMAMIDCNV_INFO pI, UINT32* pdwEndFlag)
{
	UINT8		bTrack;
	PTRACKINFO	pMt;

	*pdwEndFlag = 0;

	for (bTrack = 0; bTrack < pI->bNumOfTracks; bTrack++)
	{
		pMt = &(pI->iTrack[bTrack]);

		pMt->bSmfCmd = 0;
		pMt->dwOffset = 0;
		pMt->dwTicks = 0;
		if (pMt->dwSize > 0) *pdwEndFlag |= (1L << bTrack);
	}
}


/*=============================================================================
//	Function Name	:	SINT32	GetTrackTime(PMAMIDCNV_INFO pI, UINT32* pdwEndFlag)
//
//	Description		:	Get the 1st DT on the Track
//
//	Argument		:	bTrack		... pointer to the setup storage
//						pI			... pointer to the setup storage
//						pdwEndFlag	... pointer to the Endflag
//
//	Return			: 0 : NoError, < 0 : Error code
=============================================================================*/
static SINT32	GetTrackTime(UINT8 bTrack, PMAMIDCNV_INFO pI, UINT32* pdwEndFlag)
{
	UINT8		bTemp;
	SINT32		dwTime;
	PTRACKINFO	pMt;

	if (((*pdwEndFlag >> bTrack) & 0x01) == 0) return (-1);

	pMt = &(pI->iTrack[bTrack]);

	dwTime = 0;
	do
	{
		if (pMt->dwOffset >= pMt->dwSize)
		{
			*pdwEndFlag &= ~(1L << bTrack);
			return (-1);
		}
		bTemp = pMt->pBase[pMt->dwOffset++];
		dwTime = (dwTime << 7) + (UINT32)(bTemp & 0x7f);
	} while (bTemp >= 0x80);

	pMt->dwTicks += dwTime;
	
	if (bTrack == 7)
	{
		MASMFCNV_DBGMSG(("MaMidCnv : GetTrackTime/ %d, %ld, %ld\n", bTrack, dwTime, pMt->dwTicks));
	}

	return (0);
}


/*=============================================================================
//	Function Name	:	SINT32	GetLeastTimeTrack(PMAMIDCNV_INFO pI, UINT32* pdwEndFlag)
//
//	Description		:	Get the track has 
//
//	Argument		:	pI			... pointer to the setup storage
//						pdwEndFlag	... pointer to the Endflag
//
//	Return			: 0 : NoError, < 0 : Error code
=============================================================================*/
static SINT32	GetLeastTimeTrack(PMAMIDCNV_INFO pI, UINT32* pdwEndFlag)
{
	UINT8		bTrack;
	PTRACKINFO	pMt;
	SINT32		dwMinTicks;
	SINT32		dwMinTrack;

	dwMinTrack = -1;
	dwMinTicks = 0x7fffffffL;
	
	/*--- Get First DTs -----------------------------------*/
	for (bTrack = 0; bTrack < pI->bNumOfTracks; bTrack++)
	{
		if (((*pdwEndFlag >> bTrack) & 0x01) != 0)
		{
			pMt = &(pI->iTrack[bTrack]);

			if (dwMinTicks > pMt->dwTicks)
			{
				dwMinTicks = pMt->dwTicks;
				dwMinTrack = (SINT32)bTrack;
			}
		}
	}

	return (dwMinTrack);
}


/*=============================================================================
//	Function Name	:	SINT32	GetSMFInfo(PMAMIDCNV_INFO pI)
//
//	Description		:	Get SMF info from the file
//
//	Argument		:	pI					... pointer to the setup storage
//
//	Return			: 0 : NoError, < 0 : Error code
=============================================================================*/
static SINT32	GetSMFInfo(PMAMIDCNV_INFO pI)
{
	UINT8		bCmd;
	UINT8		bCmd2;
	UINT32		dwSize;
	
	UINT8		bTemp;
	UINT32		dwTime;
	SINT32		dwTotalTicks;
	SINT32		dwCurrentTime;

	UINT8		bSetup;			/* bit0:beat=1/420, 1:tempo=240@0, 2:beat@240, 3:tempo@240 */
	PTRACKINFO	pMt;
	UINT8		bTrack;
	SINT32		dwTr;
	UINT32		dwEndFlag;
	SINT32		dwDelta;
	UINT8		bCh;
	UINT8		bKey;
	UINT32		preBank[MAMIDCNV_MAX_CHANNELS];

	MASMFCNV_DBGMSG(("MaMidCnv : GetSMFInfo\n"));

	for (bKey = 0; bKey < 128; bKey++)
	{
		gdwMelodyVoice4op[bKey] = 0;
		gdwDrumVoice4op[bKey] = 0;
		gdwSEVoice[bKey] = 0;
		gdwExMelodyVoiceWT[bKey] = 0;
	}
	for (bCh = 0; bCh < MAMIDCNV_MAX_CHANNELS; bCh++)
	{
		gwBank[bCh] = 0x7900;
		preBank[bCh] = 0x7900;
		gdwProg[bCh] = 0;
	}
	gwBank[9] = 0x7800;
	preBank[9] = 0x7800;
	gFMMode = SMF_DEF_FM_MODE;
	bSetup = 0;
	dwTotalTicks = 0;
	dwCurrentTime = 0;
	dwDelta = (500 << 10) / pI->dwTimeResolution;	/* default=0.5sec */

	pI->bFmMode = SMF_DEF_FM_MODE;
	pI->pTitle = NULL;
	pI->dwSizeTitle = 0;
	pI->pCopyright = NULL;
	pI->dwSizeCopyright = 0;
	pI->dwStart = 0;
	pI->bSetupBar = 0;

	ResetTimeInfo(pI, &dwEndFlag);
	for (bTrack = 0; bTrack < pI->bNumOfTracks; bTrack++) GetTrackTime(bTrack, pI, &dwEndFlag);

	/*--- Check SetupBar -----------------------------*/
	if (pI->bSmfFormat == 0)
	{
		while (dwEndFlag != 0)
		{
			dwTr = GetLeastTimeTrack(pI, &dwEndFlag);
			if (dwTr < 0) break;
			pMt = &(pI->iTrack[dwTr]);
			
			dwTime = pMt->dwTicks - dwTotalTicks;
			dwCurrentTime += dwTime * dwDelta;
			dwTotalTicks = pMt->dwTicks;
			if (dwCurrentTime < 0)
			{
				MASMFCNV_DBGMSG(("MaMidCnv : GetSMFInfo Error/ CT2=%ld, %ld, %ld, %ld\n", dwCurrentTime, dwTime, dwDelta, dwTr));
				return (MASMW_ERROR_LONG_LENGTH);
			}

			bCmd = pMt->pBase[pMt->dwOffset++];

			if (bCmd < 0xf0)
			{
				bCh = (UINT8)(bCmd & 0x0F);
				/*--- MidiMsg ---*/
				if (bCmd < 0x80)
				{
					bCmd = pMt->bSmfCmd;
					if (bCmd < 0x80) return (MASMW_ERROR_SMF_CMD);
					pMt->dwOffset--;
					bCh = (UINT8)(bCmd & 0x0F);
				} else {
					if (bCmd < 0xf8) pMt->bSmfCmd = bCmd;
				}
				
				switch (bCmd & 0xf0)
				{
				case 0xC0:	/* Program change */
					gwBank[bCh] = (UINT16)preBank[bCh];
					gdwProg[bCh] = pMt->pBase[pMt->dwOffset];
					pMt->dwOffset++;
					break;