masndseq.c

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

/****************************************************************************
 *
 *		Copyright (C) 2002-2003	YAMAHA CORPORATION. All rights reserved.
 *
 *		Module		: masndseq.c
 *
 *		Description	: MA Sound Sequencer
 *
 *		Version		: 2.1.9 	2003.07.30
 *
 ****************************************************************************/

#include "mamachdep.h"
#include "madefs.h"
#include "masndseq.h"
#include "masnddrv.h"
#include "madevdrv.h"
#include "maresmgr.h"
#include "macnvprf.h"

#define MASNDSEQ_MAX_PLAYMODE	(255)
#define MASNDSEQ_STATUS_USABLE	(0x01)
#define MASNDSEQ_STATUS_NOTINIT	(0xFF)
/*
#define	MaSound_Initialize		__MaSound_Initialize
#define	MaSound_DeviceControl	__MaSound_DeviceControl
#define	MaSound_Create			__MaSound_Create
#define	MaSound_Load			__MaSound_Load
#define	MaSound_Open			__MaSound_Open
#define	MaSound_Control			__MaSound_Control
#define	MaSound_Standby			__MaSound_Standby
#define	MaSound_Seek			__MaSound_Seek
#define	MaSound_Start			__MaSound_Start
#define	MaSound_Pause			__MaSound_Pause
#define	MaSound_Restart			__MaSound_Restart
#define	MaSound_Stop			__MaSound_Stop
#define	MaSound_Close			__MaSound_Close
#define	MaSound_Unload			__MaSound_Unload
#define	MaSound_Delete			__MaSound_Delete
#define	MaSound_Terminate		__MaSound_Terminate
*/
typedef struct _MASNDSEQINFO
{
	UINT32	dSeqStatus;	/* 0xFF:not initialize smw  0x01:usable */
	UINT32	dSaveRepeat[MASMW_NUM_SEQTYPE][MASMW_NUM_FILE];
	UINT32	dCnvCount[MASMW_NUM_SEQTYPE][MASMW_NUM_FILE];
	UINT32	dRepeatCount[MASMW_NUM_SEQTYPE][MASMW_NUM_FILE];
	SINT32	sdFuncId[MASMW_NUM_SEQTYPE];
	SINT32	sdFileId[MASMW_NUM_SEQTYPE];
	UINT32	dSrmCnvMap;
	UINT32	dStartPoint[MASMW_NUM_SRMCNV][MASMW_NUM_FILE];
	UINT32	dEndPoint[MASMW_NUM_SRMCNV][MASMW_NUM_FILE];
	UINT32	dSeekPoint[MASMW_NUM_SRMCNV][MASMW_NUM_FILE];
	UINT32	dSeekPos0[MASMW_NUM_SRMCNV][MASMW_NUM_FILE];
	UINT32	dPlayLength[MASMW_NUM_SRMCNV][MASMW_NUM_FILE];
	UINT32	dLoopLength[MASMW_NUM_SRMCNV][MASMW_NUM_FILE];
	UINT8	bState[MASMW_NUM_SRMCNV][MASMW_NUM_FILE];
	SINT32 (*pfnCallBack[MASMW_NUM_SRMCNV][MASMW_NUM_FILE])(UINT8 id);
	void *	pvStartExtArgs[MASMW_NUM_SRMCNV][MASMW_NUM_FILE];
	UINT32	dHvType;
} MASNDSEQINFO, *PMASNDSEQINFO;




extern void machdep_EnterCriticalSection(void);
extern void machdep_LeaveCriticalSection(void);

/*--------------------------------------------------------------------------*/

static MASNDSEQINFO  gMaSndSeqInfo;
static PMASNDSEQINFO gpMaSndSeqInfo;

static const UINT8 bMaSeqType[MASMW_NUM_SRMCNV] = { 0, 0, 1, 1, 1, 0, 0, 1, 0, 2, 1, 1, 1 };

/*--------------------------------------------------------------------------*/
/* dummy functions                                                          */

SINT32 dummy_Init   ( void )
{
	return MASMW_ERROR_ID;
}

SINT32 dummy_Load   ( UINT8 * pbFilePtr, UINT32 dFileSize, UINT32 dMode, SINT32 (*pfnFunc)(UINT8 id), void * pvExtArgs )
{
	(void)pbFilePtr;
	(void)dFileSize;
	(void)dMode;
	(void)pfnFunc;
	(void)pvExtArgs;
	return MASMW_ERROR_ID;
}

SINT32 dummy_Open   ( SINT32 sdFileId, void * pvExtArgs )
{
	(void)sdFileId;
	(void)pvExtArgs;
	return MASMW_ERROR_ID;
}

SINT32 dummy_Control( SINT32 sdFileId, UINT32 dCtrlNum, void * pvPrm, void * pvExtArgs )
{
	(void)sdFileId;
	(void)dCtrlNum;
	(void)pvPrm;
	(void)pvExtArgs;
	return MASMW_ERROR_ID;
}

SINT32 dummy_Standby( SINT32 sdFileId, void * pvExtArgs )
{
	(void)sdFileId;
	(void)pvExtArgs;
	return MASMW_ERROR_ID;
}

SINT32 dummy_Seek   ( SINT32 sdFileId, UINT32 dPos, void * pvExtArgs )
{
	(void)sdFileId;
	(void)dPos;
	(void)pvExtArgs;
	return MASMW_ERROR_ID;
}

SINT32 dummy_Start  ( SINT32 sdFileId, void * pvExtArgs )
{
	(void)sdFileId;
	(void)pvExtArgs;
	return MASMW_ERROR_ID;
}

SINT32 dummy_Stop   ( SINT32 sdFileId, void * pvExtArgs )
{
	(void)sdFileId;
	(void)pvExtArgs;
	return MASMW_ERROR_ID;
}

SINT32 dummy_Close  ( SINT32 sdFileId, void * pvExtArgs )
{
	(void)sdFileId;
	(void)pvExtArgs;
	return MASMW_ERROR_ID;
}

SINT32 dummy_Unload ( SINT32 sdFileId, void * pvExtArgs )
{
	(void)sdFileId;
	(void)pvExtArgs;
	return MASMW_ERROR_ID;
}

SINT32 dummy_End    ( void )
{
	return MASMW_ERROR_ID;
}

/*--------------------------------------------------------------------------*/

/****************************************************************************
 *	MaSound_ReceiveMessage
 *
 *	Function:
 *			Receive the message from MA Sound Driver.
 *	Argument:
 *			sdSeqId		Sequence Type  (0..2)
 *			sdFileId	file id  (0..5)
 *			bmessage	message type
 *	Return:
 *			0		success
 *			127		end
 *			< 0		error code
 *
 ****************************************************************************/
SINT32 MaSound_ReceiveMessage
(
	SINT32	sdSeqId,					/* sequence id */
	SINT32	sdFileId,					/* file id */
	UINT8	bMessage					/* message number */
)
{
	SINT32	sdFuncId;					/* function id */
	SINT32	sdResult;					/* result of function */

	MASNDSEQ_DBGMSG(("MaSndSeq_ReceiveMessage: id=%ld fid=%ld msg=%d\n", sdSeqId, sdFileId, bMessage));

	sdFuncId = gpMaSndSeqInfo->sdFuncId[sdSeqId];
	if ( sdSeqId != MASMW_SEQTYPE_DIRECT )
		sdFileId = gpMaSndSeqInfo->sdFileId[sdSeqId];

	switch ( bMessage )
	{
	case MASMW_END_OF_DATA:

		if ( gpMaSndSeqInfo->dCnvCount[sdSeqId][sdFileId] == 0xFFFF )
		{
			return MASMW_END_OF_SEQUENCE;
		}

		if ( gpMaSndSeqInfo->dCnvCount[sdSeqId][sdFileId] != 0 )
		{
			gpMaSndSeqInfo->dCnvCount[sdSeqId][sdFileId]--;
			if ( gpMaSndSeqInfo->dCnvCount[sdSeqId][sdFileId] == 0 )
			{
				gpMaSndSeqInfo->dCnvCount[sdSeqId][sdFileId] = 0xFFFF;

				return MASMW_END_OF_SEQUENCE;
			}
		}

		MaSndDrv_ControlSequencer( sdSeqId, MASNDDRV_SEQUENCER_ENTERREPEAT );

		if ( gpMaSndSeqInfo->bState[sdFuncId][sdFileId] == MASMW_STATE_PLAYING )
		{
			sdResult = ma_srmcnv_func[sdFuncId].Stop( sdFileId, NULL );
			if ( sdResult < MASMW_SUCCESS ) return sdResult;
		
			sdResult = ma_srmcnv_func[sdFuncId].Seek( sdFileId, gpMaSndSeqInfo->dStartPoint[sdFuncId][sdFileId], NULL );
			if ( sdResult < MASMW_SUCCESS ) return sdResult;
			sdResult = ma_srmcnv_func[sdFuncId].Start( sdFileId, gpMaSndSeqInfo->pvStartExtArgs[sdFuncId][sdFileId] );
			if ( sdResult < MASMW_SUCCESS ) return sdResult;
		}
		else
		{
			sdResult = ma_srmcnv_func[sdFuncId].Seek( sdFileId, gpMaSndSeqInfo->dStartPoint[sdFuncId][sdFileId], NULL );
			if ( sdResult < MASMW_SUCCESS ) return sdResult;
		}

		MaSndDrv_ControlSequencer( sdSeqId, MASNDDRV_SEQUENCER_LEAVEREPEAT );

		break;
		
	case MASMW_END_OF_SEQUENCE:


		if ( gpMaSndSeqInfo->dRepeatCount[sdSeqId][sdFileId] == 0xFFFF )
		{
			bMessage = MASMW_END_OF_SEQUENCE;
		}
		else 
		{
			if ( gpMaSndSeqInfo->dRepeatCount[sdSeqId][sdFileId] != 0 )
			{
				gpMaSndSeqInfo->dRepeatCount[sdSeqId][sdFileId]--;
			
				if ( ( sdSeqId != 0) ||
					 ( gpMaSndSeqInfo->dRepeatCount[sdSeqId][sdFileId] == 0 ) )
				{
					gpMaSndSeqInfo->dRepeatCount[sdSeqId][sdFileId] = 0xFFFF;
					gpMaSndSeqInfo->dCnvCount[sdSeqId][sdFileId]    = 0xFFFF;
					

					if ( sdSeqId == 0 )
					{
						if ( gpMaSndSeqInfo->bState[sdFuncId][sdFileId] == MASMW_STATE_PLAYING )
						{
							sdResult = ma_srmcnv_func[sdFuncId].Stop( sdFileId, NULL );
							if ( sdResult < MASMW_SUCCESS ) return sdResult;
						}
					}
	
					gpMaSndSeqInfo->bState[sdFuncId][sdFileId] = MASMW_STATE_READY;

					bMessage = MASMW_END_OF_SEQUENCE;
				}
				else
				{
					gpMaSndSeqInfo->dSeekPoint[sdFuncId][sdFileId] =
						gpMaSndSeqInfo->dStartPoint[sdFuncId][sdFileId]
					  + gpMaSndSeqInfo->dSeekPos0[sdFuncId][sdFileId];

					if ( sdSeqId == 0 )
		  				MaSndDrv_ResetPos( sdSeqId );
					bMessage = MASMW_REPEAT;

					if ( sdSeqId == 0 )
					{
						if ( gpMaSndSeqInfo->bState[sdFuncId][sdFileId] == MASMW_STATE_PLAYING )
						{
							MaDevDrv_WriteIntermediateReg( MAI_SEQ_CTRL, 0x01 );
						}
					}
				}
			}
			else
			{
				gpMaSndSeqInfo->dSeekPoint[sdFuncId][sdFileId] =
					gpMaSndSeqInfo->dStartPoint[sdFuncId][sdFileId]
				  + gpMaSndSeqInfo->dSeekPos0[sdFuncId][sdFileId];
			 
				if ( sdSeqId == 0 )
					MaSndDrv_ResetPos( sdSeqId );
				bMessage = MASMW_REPEAT;

				if ( sdSeqId == 0 )
				{
					if ( gpMaSndSeqInfo->bState[sdFuncId][sdFileId] == MASMW_STATE_PLAYING )
					{
						MaDevDrv_WriteIntermediateReg( MAI_SEQ_CTRL, 0x01 );
					}
				}
			}
		}
	
	
	default:

		if ( gpMaSndSeqInfo->pfnCallBack[sdFuncId][sdFileId] != NULL )
		{
			gpMaSndSeqInfo->pfnCallBack[sdFuncId][sdFileId]( bMessage );
		}
		break;
	}
	
	return MASMW_SUCCESS;
}
/****************************************************************************
 *	MaSound_Create
 *
 *	Function:
 *			Setting the MA Stream Converter and callback function.
 *	Argument:
 *			bCnvId		ID number of MA Stream Converter
 *	Return:
 *			>= 0		function id of registered MA Stream Converter
 *			< 0			error code
 *
 ****************************************************************************/
SINT32 MaSound_Create
(
	UINT8	bCnvId						/* stream converter id */
)
{
	UINT32	i;							/* loop counter */
	SINT32	sdResult;					/* result of function */

	MASNDSEQ_DBGMSG(("MaSound_Create: cnv_id=%d\n", bCnvId));
	
	if ( gpMaSndSeqInfo->dSeqStatus != MASNDSEQ_STATUS_USABLE )
	{
		return MASMW_ERROR;
	}

	if ( bCnvId >= MASMW_NUM_SRMCNV )
	{
		return MASMW_ERROR;
	}

	if ( ( gpMaSndSeqInfo->dSrmCnvMap & (UINT32)(1 << bCnvId) ) != 0 )
	{
		return MASMW_ERROR;
	}

	sdResult = ma_srmcnv_func[bCnvId].Init();

	if ( sdResult < MASMW_SUCCESS )
	{
		MASNDSEQ_DBGMSG(("Can't initialize the stream converter\n"));
		return sdResult;
	}

	/* set HV language type */
	if ( bCnvId == MASMW_CNVID_HVS )
	{
		ma_srmcnv_func[bCnvId].Control( 0, MASMW_SET_HVLANGUAGE, (void *)&gpMaSndSeqInfo->dHvType, NULL );
	}

	for ( i = 0; i < MASMW_NUM_FILE; i++ )
	{
		gpMaSndSeqInfo->bState[bCnvId][i] = MASMW_STATE_IDLE;
	}

	gpMaSndSeqInfo->dSrmCnvMap |= (UINT32)(1 << bCnvId);

	return (SINT32)bCnvId;
}
/****************************************************************************
 *	MaSound_Load
 *
 *	Function:
 *			Performs loading processing of Stream Converter.
 *	Arguments:
 *			sdFuncId	function id
 *			pbFilePtr	pointer to file
 *			dFileSize	byte size of file
 *			bMode		error check mode	0: no check
 *											1: check
 *											2: check only
 *											3: get contents information
 *			pfnFunc		callback function
 *			pvExtArgs	for future extension
 *	Return:
 *			>= 0		success. file id.
 *			< 0			error code
 *
 ****************************************************************************/
SINT32 MaSound_Load
(
	SINT32	sdFuncId, 					/* function id */
	UINT8 *	pbFilePtr,					/* pointer to file */
	UINT32	dFileSize,					/* size of file */
	UINT8	bMode,						/* error check mode */
	SINT32	(*pfnFunc)(UINT8 bId),		/* callback function */
	void *	pvExtArgs					/* for future extension */
)
{
	SINT32	sdResult;					/* result of function */
	
	MASNDSEQ_DBGMSG(("MaSound_Load: id=%ld\n", sdFuncId));

	/* check sdFuncId */
	if ( (sdFuncId < 0) || (sdFuncId >= MASMW_NUM_SRMCNV) )
	{
		return MASMW_ERROR;
	}
	if ( ( gpMaSndSeqInfo->dSrmCnvMap & (UINT32)(1 << sdFuncId) ) == 0 )
	{
		return MASMW_ERROR;
	}
	
	/* check mode */
	if ( bMode > 3 )
	{
		return MASMW_ERROR_ARGUMENT;
	}

	/* call a stream converter */
	sdResult = ma_srmcnv_func[sdFuncId].Load( pbFilePtr, dFileSize, (UINT32)bMode, pfnFunc, pvExtArgs );

	if ( sdResult >= MASMW_SUCCESS )
	{
		/* status doesn't change, if sdResult == 0 */
		if ( sdResult == 0 )
		{
			return sdResult;
		}

		/* change status to LOADED */
		gpMaSndSeqInfo->bState[sdFuncId][sdResult] = MASMW_STATE_LOADED;

		/* register a callback function */
		gpMaSndSeqInfo->pfnCallBack[sdFuncId][sdResult] = pfnFunc;
	}
	
	return sdResult;
}
/****************************************************************************
 *	MaSound_Open
 *
 *	Function:
 *			Performs opening processing of Stream Converter.
 *	Arguments:
 *			sdFuncId	function id
 *			sdFileId	file id
 *			wOpenMode	file open mode
 *			pvExtArgs	for future extension
 *	Return:
 *			0			success
 *			< 0 		error code
 *
 ****************************************************************************/
SINT32 MaSound_Open
(
	SINT32	sdFuncId,					/* function id */
	SINT32	sdFileId,					/* file id */
	UINT16	wOpenMode,					/* open mode */
	void *	pvExtArgs					/* for future extension */
)
{
	SINT32	sdResult;					/* result of function */
	SINT32	sdResult2;					/* result of function */
	
	MASNDSEQ_DBGMSG(("MaSound_Open: id=%ld hd=%ld md=%hd\n", sdFuncId, sdFileId, wOpenMode));
	
	(void)wOpenMode;

	/* check sdFuncId and sdFileId */
	if ( (sdFuncId < 0) || (sdFuncId >= MASMW_NUM_SRMCNV) )
	{
		return MASMW_ERROR;
	}
	if ( ( ( gpMaSndSeqInfo->dSrmCnvMap & (UINT32)(1 << sdFuncId) ) == 0 )
		|| ( sdFileId < 0 ) || ( sdFileId >= MASMW_NUM_FILE ) )
	{
		return MASMW_ERROR;
	}

	/* check status */
	if ( gpMaSndSeqInfo->bState[sdFuncId][sdFileId] != MASMW_STATE_LOADED )
	{
		return MASMW_ERROR;
	}

	/* call a stream converter */
	sdResult = ma_srmcnv_func[sdFuncId].Open( sdFileId, pvExtArgs );

	if ( sdResult >= MASMW_SUCCESS )
	{
		if ( bMaSeqType[sdFuncId] != 2 )
		{
			/* set default endpoint */
			
			/* get length of data */
			sdResult = ma_srmcnv_func[sdFuncId].Control( sdFileId, MASMW_GET_LENGTH, NULL, NULL );
			if ( sdResult < MASMW_SUCCESS )
			{
				return sdResult;
			}

			sdResult2 = ma_srmcnv_func[sdFuncId].Control( sdFileId, MASMW_GET_LENGTH, NULL, (void *)(-1) );
			if ( sdResult2 < MASMW_SUCCESS )
			{
				return sdResult2;
			}

			/* set start point and end point */
			gpMaSndSeqInfo->dStartPoint[sdFuncId][sdFileId] = 0;
			gpMaSndSeqInfo->dEndPoint[sdFuncId][sdFileId]   = (UINT32)sdResult;

			/* reset value of seek */
			gpMaSndSeqInfo->dSeekPoint[sdFuncId][sdFileId]  = 0;

			/* set length of data */
			gpMaSndSeqInfo->dPlayLength[sdFuncId][sdFileId] = (UINT32)sdResult;
			gpMaSndSeqInfo->dLoopLength[sdFuncId][sdFileId] = (UINT32)sdResult2;
		}
		else
		{
			gpMaSndSeqInfo->dStartPoint[sdFuncId][sdFileId] = 0;
			gpMaSndSeqInfo->dEndPoint[sdFuncId][sdFileId] = 0xFFFFFFFF;
			gpMaSndSeqInfo->dSeekPoint[sdFuncId][sdFileId] = 0;
			gpMaSndSeqInfo->dPlayLength[sdFuncId][sdFileId] = 0xFFFFFFFF;
			gpMaSndSeqInfo->dLoopLength[sdFuncId][sdFileId] = 0xFFFFFFFF;
		}

		/* change status to OPENED */
		gpMaSndSeqInfo->bState[sdFuncId][sdFileId] = MASMW_STATE_OPENED;

		sdResult = MASMW_SUCCESS;
	}

	return sdResult;
}
/****************************************************************************
 *	MaSound_Control
 *
 *	Function:
 *			Performs controlling processing of Stream Conveter.
 *	Argument:
 *			sdFuncId	function id
 *			sdFileId	file id
 *			bCtrlNum	control number
 *			pvPrm		control parameter