vgsnd.c

adc 3208 上面实现图片旋转的实例

//************************************************************************************
//
// 	TITLE 	: Sound Control Functions for VRender Series
// 	DESCRIPT: Sound Control Functions
//
//************************************************************************************


#include "vgSnd.h"

U16		_vgSoundMainControlRegister = 0;
U16		_vgSoundChannelControlRegister = 0;
U32		_vgReverbeControlRegister = 0;

float	_vgSoundPlayFrequencyFloat = 44100.f;
U32		_vgSoundPlayFrequency = 44100UL;
U16		_vgSoundMaxChannel = 32;

U32		_vgSoundVR0Clk = 86000000;
vgBOOL	_vgSoundForceMono = vgFALSE;

_DGSNDCHANNEL _vgSndChannel[32];
//_MIDI_TONE    midi_tone[ROUND_BUF_NUM];

vgBOOL	_vgRevTM, _vgRevEn;

// Sound Initialize
vgBOOL	SndInit( void )
{
	int i;

	_vgSoundMainControlRegister = 0;
	_vgSoundChannelControlRegister = 0;
	
	vgSndStopSound();
	for( i=0 ; i<32 ; i++ )		// set idle status of all channel
	{
		vgSndSetStatusIdle( (U8)i );
		vgSndSetNoteOff( (U8)i );
	}

	vgSndSetIntMask( 0xFFFFFFFF );	// disable interrupt of all channel
	vgSndSetIntPend( 0xFFFFFFFF );	// clear pending of all channel

	vgSndSelectWait( vgFALSE, vgFALSE, vgFALSE );
	vgSndSetMaxChannel( 32 );
	vgSndSetChannelPerClockNumber( 0xFF );
	vgSndReverbeEnable( vgFALSE );
	vgSndSelectRevebeMemory( vgFALSE );
	vgSndSetReverbeFactor( 0 );
	vgSndSetReverbeBufferAddress( 0 );
	vgSndSetReverbeBufferSize( 0, 0, 0, 0 );

//zy	_VGMSG(( "vgSndInit Complete.\r\n" ));
	return vgTRUE;
}

void	vgSndClose( void )
{
	vgSndStopSound();
}


void	vgSndForceMono( vgBOOL enb )
{
	_vgSoundForceMono = enb;	
}
/*
U32		vgSNDRead( U32 addr )
{
	U32 DataLow, DataHigh;

	_VGASSERTMSG( (!(addr&0x3UL)), ("SndRead Address(0x%08X) must be aligned on word\r\n", addr) );

	DataLow = (U32)CPURead16( DG_LOW(addr) );
	DataHigh = (U32)CPURead16( DG_HIGH(addr) );

	return	( DataLow | (DataHigh<<16) );
}

void	vgSNDWrite( U32 addr, U32 data )
{
	_VGASSERTMSG( (!(addr&0x3UL)), ("SndWrite Address(0x%08X) must be aligned on word\r\n", addr) );

	CPUWrite16( DG_LOW(addr), (U16)(data&0x0000FFFF) );
	CPUWrite16( DG_HIGH(addr), (U16)((data&0xFFFF0000)>>16) );
}
*/

void	vgSndSetStatus( U8 channel, vgBOOL stats )
{
	if( stats == DG_SND_STATUS_BUSY )
		CPUWrite16( DG_SND_STATUS, (U16)(DG_BIT(15) | (U16)channel) );
	else
		CPUWrite16( DG_SND_STATUS, (U16)channel );
}

void	vgSndSetNote( U8 channel, vgBOOL stats )
{
	if( stats == DG_SND_NOTE_ON )	
		CPUWrite16( DG_SND_NOTE, (U16)(DG_BIT(15) | (U16)channel) );
	else
		CPUWrite16( DG_SND_NOTE, (U16)channel );
}

void	vgSndSetDataFile( U8 channel, _DGSNDCHANNEL *sc )
{
	U32 i;
	U32 p[8];

	p[0] =	(U32)sc->CurSAddr;
	p[1] =	(0x3UL<<29) |
			((((U32)sc->LoopDir     )&0x00000001)<<28) |
			((((U32)sc->EnvStage    )&0x0000000F)<<24) |
			((((U32)sc->EnvVol      )&0x00FFFFFF));
	p[2] =	((((U32)sc->Mode        )&0x0000007F)<<24) |
			((((U32)sc->dSAddr      )&0x0000FFFF));
	p[3] =	((((U32)sc->LChnVol     )&0x0000007F)<<24) |
			((((U32)sc->LoopBegin   )&0x003FFFFF));
	p[4] =	((((U32)sc->RChnVol     )&0x0000007F)<<24) |
			((((U32)sc->LoopEnd     )&0x003FFFFF));
	p[5] =	((((U32)sc->EnvRate[1]  )&0x0000FFFF)<<16) |
			((((U32)sc->EnvRate[0]  )&0x0000FFFF));
	p[6] =	((((U32)sc->EnvRate[3]  )&0x0000FFFF)<<16) |
			((((U32)sc->EnvRate[2]  )&0x0000FFFF));
	p[7] =	((((U32)sc->EnvRate[3]  )&0x00010000)<<15) |
			((((U32)sc->EnvRate[2]  )&0x00010000)<< 7) |
			((((U32)sc->EnvRate[1]  )&0x00010000)>> 1) |
			((((U32)sc->EnvRate[0]  )&0x00010000)>> 9) |
			((((U32)sc->EnvTarget[3])&0x0000007F)<<24) |
			((((U32)sc->EnvTarget[2])&0x0000007F)<<16) |
			((((U32)sc->EnvTarget[1])&0x0000007F)<< 8) |
			((((U32)sc->EnvTarget[0])&0x0000007F)<< 0);

	for( i=0 ; i<8 ; i++ )
		vgSNDWrite( DG_SND_CHANNEL_PARAMTER_REGISTER + (U32)channel*32 + i*4, p[i] );
}

void	vgSndSetDataFileNoEnvelope( U8 channel, _DGSNDCHANNEL *sc )
{
	U32 i;
	U32 p[8];

	p[0] =	(U32)sc->CurSAddr;
	p[1] =	(0x3UL<<29) |
			((((U32)sc->LoopDir     )&0x00000001)<<28) |
			((((U32)sc->EnvStage    )&0x0000000F)<<24) |
			((((U32)sc->EnvVol      )&0x00FFFFFF));
	p[2] =	((((U32)sc->Mode        )&0x0000007F)<<24) |
			((((U32)sc->dSAddr      )&0x0000FFFF));
	p[3] =	((((U32)sc->LChnVol     )&0x0000007F)<<24) |
			((((U32)sc->LoopBegin   )&0x003FFFFF));
	p[4] =	((((U32)sc->RChnVol     )&0x0000007F)<<24) |
			((((U32)sc->LoopEnd     )&0x003FFFFF));

	for( i=0 ; i<5 ; i++ )
		vgSNDWrite( DG_SND_CHANNEL_PARAMTER_REGISTER + (U32)channel*32 + i*4, p[i] );
}


void	vgSndSetDataFileByType( U8 channel, _DGSNDCHANNEL *sc, U32 type )
{
	U32 p;

	if( type | DG_SND_TYPE_OFFSET_3 )
	{
		p =	((((U32)sc->LChnVol     )&0x0000007F)<<24) |
			((((U32)sc->LoopBegin   )&0x003FFFFF));
		vgSNDWrite( DG_SND_CHANNEL_PARAMTER_REGISTER + (U32)channel*32 + 12, p );
	}
	if( type | DG_SND_TYPE_OFFSET_4 )
	{
		p =	((((U32)sc->RChnVol     )&0x0000007F)<<24) |
			((((U32)sc->LoopEnd     )&0x003FFFFF));
		vgSNDWrite( DG_SND_CHANNEL_PARAMTER_REGISTER + (U32)channel*32 + 16, p );
	}
}

void	vgSndPlaySound( void )
{
	_vgSoundMainControlRegister |= DG_BIT(15);
	CPUWrite16( DG_SND_MAIN_CONTROL, _vgSoundMainControlRegister ); 
}

void	vgSndPauseSound( void )
{
	_vgSoundMainControlRegister &= ~DG_BIT(15);
	CPUWrite16( DG_SND_MAIN_CONTROL, _vgSoundMainControlRegister ); 
}

void	vgSndStopSound( void )
{
	int i;
	
	vgSndPauseSound();
	for( i=0 ; i<_vgSoundMaxChannel ; i++ )	vgSndStopChannel( (U8) i );
}

void	vgSndSelectRevebeMemory( vgBOOL IsTmem )
{
	_vgRevTM = IsTmem;
	if( IsTmem )	_vgSoundMainControlRegister |= DG_BIT(5);
	else			_vgSoundMainControlRegister &= ~DG_BIT(5);
	CPUWrite16( DG_SND_MAIN_CONTROL, _vgSoundMainControlRegister ); 
}

void	vgSndReverbeEnable( vgBOOL re )
{
	_vgRevEn = re;
	if( re )	_vgSoundMainControlRegister |= DG_BIT(4);
	else		_vgSoundMainControlRegister &= ~DG_BIT(4);
	CPUWrite16( DG_SND_MAIN_CONTROL, _vgSoundMainControlRegister ); 
}

void	vgSndSelectWait( vgBOOL cw, vgBOOL aw, vgBOOL mw )
{
	_vgSoundMainControlRegister 
	= (_vgSoundMainControlRegister & ~(DG_BIT(2) | DG_BIT(1) | DG_BIT(0))) |
	  ( (cw) ? DG_BIT(2) : 0 ) |
	  ( (aw) ? DG_BIT(1) : 0 ) |
	  ( (mw) ? DG_BIT(0) : 0 );
	CPUWrite16( DG_SND_MAIN_CONTROL, _vgSoundMainControlRegister ); 
}

void	vgSndSetMaxChannel( U16 maxchan )
{
//zy	_VGASSERTMSG( (maxchan>0 && maxchan<=32), ("A number of Channel(%d) must be in 1 to 32\r\n", maxchan) );
	
	_vgSoundMaxChannel = maxchan;
	_vgSoundChannelControlRegister 
		= (_vgSoundChannelControlRegister & ~(0x001F<<8)) | (((maxchan-1)&0x001F)<<8);
	CPUWrite16( DG_SND_CHANNEL_CONTROL, _vgSoundChannelControlRegister ); 
}

void	vgSndSetChannelPerClockNumber( U16 clknum )
{
	_vgSoundChannelControlRegister 
	= (_vgSoundChannelControlRegister & 0xFF00) | (clknum&0x00FF);
	CPUWrite16( DG_SND_CHANNEL_CONTROL, _vgSoundChannelControlRegister ); 
}

void	vgSndSetPlayFrequency( float vr0clk, float playfrequency )
{
	U32	ChnClkNum = (U32)(vr0clk/(playfrequency*64.0f) + 0.5f) - 1;

	_vgSoundVR0Clk = (U32)vr0clk;
	vgSndSetChannelPerClockNumber( (U16)ChnClkNum );

	// recalculation for output frequency
	_vgSoundPlayFrequencyFloat = vr0clk / (64.f * (float)(ChnClkNum+1));
	_vgSoundPlayFrequency = (U32)(_vgSoundPlayFrequencyFloat + 0.5f);
}

void	vgSndSetReverbeFactor( U16 revmul )
{
	CPUWrite16( DG_SND_REVFACTOR, revmul ); 
}

void	vgSndSetReverbeBufferAddress( U32 address )
{
//zy	_VGASSERTMSG( !(address&0x0000FFFFUL), ("Reverbe Buffer Address must be align on 64K bytes\r\n") );
	CPUWrite16( DG_SND_REVBUFSTART, (U16)(address>>16) ); 
}

void	vgSndSetReverbeBufferSize( U16 size0, U16 size1, U16 size2, U16 size3 )
{
	CPUWrite16( DG_SND_REVBUFSIZE0, size0 );
	CPUWrite16( DG_SND_REVBUFSIZE1, size1 );
	CPUWrite16( DG_SND_REVBUFSIZE2, size2 );
	CPUWrite16( DG_SND_REVBUFSIZE3, size3 );
}

/*
void	vgSndPlayChannel( U8 channel )
{
	CPUWrite16( DG_SND_STATUS, (U16)(DG_BIT(15) | (U16)channel) );
}

void	vgSndStopChannel( U8 channel )
{
	CPUWrite16( DG_SND_STATUS, (U16)channel );
}

U32		vgSndGetStatus( void )
{
	return vgSNDRead( DG_SND_STATUS );
}

void	vgSndSetNoteOn( U8 channel )
{
	CPUWrite16( DG_SND_NOTE, (U16)(DG_BIT(15) | (U16)channel) );
}

void	vgSndSetNoteOff( U8 channel )
{
	CPUWrite16( DG_SND_NOTE, (U16)channel );
}

U32		vgSndGetNote( void )
{
	return vgSNDRead( DG_SND_NOTE );
}

void	vgSndSetIntMask( U32 mask )
{
	vgSNDWrite( DG_SND_INTMASK, mask );
}

U32		vgSndGetIntMask( void )
{
	return vgSNDRead( DG_SND_INTMASK );
}

void	vgSndClearIntPend( U8 channel )
{
	U32 pend = 1UL<<channel;
	vgSNDWrite( DG_SND_INTPEND, pend );
}

void	vgSndSetIntPend( U32 pend  )
{
	vgSNDWrite( DG_SND_INTPEND, pend );
}

U32		vgSndGetIntPend( void )
{
	return vgSNDRead( DG_SND_INTPEND );
}
*/