#include <stdio.h>
#include <conio.h>
#include <newtype.h>
#include "Live3D.h"

#define ST_____97

#define OUTP outp
#define INP  inp

//-----------------------------------------------------------------
//
// AD Mixer
//
//	5:Fm
//  6:I2S1
//  14:Master
//  16:Aux,Synth
//
//-----------------------------------------------------------------

#define READPORT			inp
#define WRITEPORT			outp
#define BASE				0x530
#define C1815_ADDRESS		(BASE+0)
#define C1815_INDDATA_LO    (BASE+2)
#define C1815_INDDATA_HI    (BASE+3)
#define LOBYTE(x)			((BYTE)(x&0xFF))
#define HIBYTE(x)			((BYTE)((x>>8)&0xFF))

WORD
C1815_RegRead(BYTE bReg)
{
	WORD wRetVal;
	BYTE bTemp;

	bTemp = READPORT( C1815_ADDRESS ) ;
	WRITEPORT( C1815_ADDRESS, (bTemp & 0xC0) | (bReg & 0x3F) ) ;

	wRetVal = (WORD) READPORT( C1815_INDDATA_HI ) << 8;
	wRetVal |= READPORT( C1815_INDDATA_LO ) ;

	return (wRetVal) ;

} /* C1815_RegRead() */


BOOL
C1815_RegWrite(BYTE bReg, WORD wValue)
{
	BYTE bTemp;

	bTemp = READPORT( C1815_ADDRESS ) ;
	WRITEPORT( C1815_ADDRESS, (bTemp & 0xC0) | (bReg & 0x3f) ) ;

	WRITEPORT( C1815_INDDATA_LO, LOBYTE(wValue) );
	WRITEPORT( C1815_INDDATA_HI, HIBYTE(wValue) );

	return (TRUE);

} /* C1815_RegWrite() */

void ModeWSS( void )
{
	WORD r;

	r = C1815_RegRead( 32 );

	r &= 0x7FFF;
	r |= 0x8000;

	C1815_RegWrite( 32, r );
}

void ModeSB( void )
{
	WORD r;

	r = C1815_RegRead( 32 );

	r &= 0x7FFF;

	C1815_RegWrite( 32, r );
}

void I2SEnable( void )
{
	WORD r;

	r = C1815_RegRead( 32 );

	r &= ~0xC;
	r |= 0x8;

	C1815_RegWrite( 32, r );
}

void AdInit( void )
{

	I2SEnable();

	// unMute each line
	C1815_RegWrite( 5, 0x7F7F&C1815_RegRead( 5 ));
	C1815_RegWrite( 6, 0x7F7F&C1815_RegRead( 6 ));
	C1815_RegWrite( 14, 0x7F7F&C1815_RegRead( 14 ));
	C1815_RegWrite( 16, 0x7F7F&C1815_RegRead( 16 ));

	// vol to max
	C1815_RegWrite( 14, 0x0808);
	C1815_RegWrite( 17, 0x0808 ); //video
	C1815_RegWrite( 19, 0x8000 ); //mic phone

}

void AD_Mixer_Out( int reg, int val )
{
	WORD v=val&0xFF;
	v<<=8;
	v|=(val&0xFF);
	C1815_RegWrite( reg, v );
}

//-----------------------------------------------------------------
//
// SB Pro Mixer
//
//-----------------------------------------------------------------
WORD SBPort = 0x220;

void SB_SetPort(unsigned val)
{
	SBPort = val;
}

void SB_Mixer_Out(unsigned reg, unsigned val)
{
	int v = ((val<<4)|(val&0xf));
	OUTP(SBPort+0x4, (char)reg);
	OUTP(SBPort+0x5, (char)v);
}

BYTE SB_Mixer_In(int reg)
{
	OUTP(SBPort+0x4, (char)reg);
	return (BYTE)INP(SBPort+0x5);
}

void Set_SB_Mixer ( int p, int v )
{
	int v2;

	S94_Save( p, v );

	v2 = v&0xF;
	v2 = (v2<<4) | v2;

	switch( p )
	{
	case SB_MASTER 	: SB_Mixer_Out(0x22,v2);break;//master
	case SB_WAV 	: SB_Mixer_Out(0x4 ,v2);break;//wave vol
	case SB_FM 		: SB_Mixer_Out(0x26,v2);break;//fm volume
	case SB_CD 		: SB_Mixer_Out(0x28,v2);break;//cd volume
	case SB_LINE  	: SB_Mixer_Out(0x2e,v2);break;//line volume
	case SB_MIC   	: SB_Mixer_Out(0xa, v );break;//mic-phone volume
	case SB_MIDI   	: AD_Mixer_Out(5,  SMAX(SB_MIDI)-v );
					  AD_Mixer_Out(6,  SMAX(SB_MIDI)-v ); break;
	case SB_ECHO   	: AD_Mixer_Out(16, SMAX(SB_ECHO)-v ); break;
	}
}

//-----------------------------------------------------------------
//
// SAM Mixer
//
//-----------------------------------------------------------------
int GetMAX(int i )
{
	switch(i)
	{
	  case 0   : return SMAX(SB_MASTER   );
	  case 1   : return SMAX(SB_WAV      );
	  case 2   : return SMAX(SB_FM       );
	  case 3   : return SMAX(SB_CD       );
	  case 4   : return SMAX(SB_LINE     );
	  case 5   : return SMAX(SB_MIC      );
#ifdef ST_____97
	  case 6   : return SMAX(GM_VOL      );
	  case 7   : return SMAX(EQ_LBL      );
	  case 8   : return SMAX(EQ_MLBL     );
	  case 9   : return SMAX(EQ_MHBL     );
	  case 10  : return SMAX(EQ_HBL      );
	  case 11  : return SMAX(SUR_VOL     );
	  case 12  : return SMAX(SUR_DEL     );

	  case 0x100 : return SMAX(ECH_LEV	 );
	  case 0x101 : return SMAX(ECH_TIM	 );
	  case 0x102 : return SMAX(ECH_FEED	 );

	  case 0x400 : return SMAX( REV_VOL   );
	  case 0x401 : return SMAX( REV_TIME  );
	  case 0x402 : return SMAX( REV_FEED  );

	  case 0x403 : return SMAX( CHR_VOL   );
	  case 0x404 : return SMAX( CHR_DEL   );
	  case 0x405 : return SMAX( CHR_FEED  );
	  case 0x406 : return SMAX( CHR_RATE  );
	  case 0x407 : return SMAX( CHR_DEPTH );

	  case 0x408 : return SMAX( AUDREV_SEND );
	  case 0x409 : return SMAX( AUDCHR_SEND );
	  case 0x40a : return SMAX( GMREV_SEND );
	  case 0x40b : return SMAX( GMCHR_SEND );
#else
	  case 6   : return SMAX(SB_MIDI     );
	  case 7   : return SMAX(SB_ECHO     );
#endif
	}
	return 0;
}

int GetStep( int i )
{
	int r=(GetMAX( i )+1)>>4;
	if(r==0) r=1;
	return r;
}

void S94_SetChr( int idx )
{
	int nChr[8][5] =
	{
		0x90, 0x4b, 0x00, 0x03, 0x05,
		0x90, 0x40, 0x07, 0x09, 0x13,
		0x90, 0x40, 0x09, 0x03, 0x13,
		0x90, 0x2b, 0x0c, 0x09, 0x10,
		0x90, 0x7f, 0x48, 0x02, 0x0c,
		0x90, 0x56, 0x7f, 0x01, 0x03,
		0xff, 0x7f, 0x00, 0x00, 0x00,
		0xff, 0x7f, 0x50, 0x00, 0x00
	};

	S94_SetGenDev( CHR_VOL     , nChr[idx][0]);
	S94_SetGenDev( CHR_DEL     , nChr[idx][1]);
	S94_SetGenDev( CHR_FEED    , nChr[idx][2]);
	S94_SetGenDev( CHR_RATE    , nChr[idx][3]);
	S94_SetGenDev( CHR_DEPTH   , nChr[idx][4]);
}

void S94_SetRev( int idx )
{
	int nRev[8][3] =
	{
		0x90, 0x7f, 0x00,
		0x90, 0x7f, 0x00,
		0x90, 0x7f, 0x00,
		0xc0, 0x7f, 0x00,
		0x90, 0x7f, 0x00,
		0x90, 0x7f, 0x00,
		0xff, 0x18, 0x22,
		0xff, 0x7f, 0x26
	};

	S94_SetGenDev( REV_VOL     , nRev[idx][0] );
	S94_SetGenDev( REV_TIME    , nRev[idx][1] );
	S94_SetGenDev( REV_FEED    , nRev[idx][2] );
}

void MixerMessage( int id, int v )
{

	switch( id )
	{
	case 0x100     	: S94_SetGenDev( ECH_LEV     , v);break;
	case 0x101     	: S94_SetGenDev( ECH_TIM     , v);break;
	case 0x102    	: S94_SetGenDev( ECH_FEED    , v);break;

	case 0x200    	: S94_SetGenDev( REV_TYPE    , v); S94_SetRev( v ); break;
	case 0x208    	: S94_SetGenDevACK( REV_ONOFF, v);break;

	case 0x300    	: S94_SetGenDev( CHR_TYPE    , v); S94_SetChr( v ); break;
	case 0x308    	: S94_SetGenDevACK( CHR_ONOFF, v);break;

	case 0x400      : S94_SetGenDev( REV_VOL  , v);break;
	case 0x401      : S94_SetGenDev( REV_TIME , v);break;
	case 0x402      : S94_SetGenDev( REV_FEED , v);break;

	case 0x403      : S94_SetGenDev( CHR_VOL   , v);break;
	case 0x404      : S94_SetGenDev( CHR_DEL   , v);break;
	case 0x405      : S94_SetGenDev( CHR_FEED  , v);break;
	case 0x406      : S94_SetGenDev( CHR_RATE  , v);break;
	case 0x407      : S94_SetGenDev( CHR_DEPTH , v);break;

	case 0x408      : S94_SetGenDev( AUDREV_SEND , v);break;
	case 0x409      : S94_SetGenDev( AUDCHR_SEND , v);break;
	case 0x40a      : S94_SetGenDev( GMREV_SEND , v);break;
	case 0x40b      : S94_SetGenDev( GMCHR_SEND , v);break;

	case 0x500      : S94_SetGenDev( SUR_INP     , v);break;

	case 0x600      : S94_SetGenDev( SUR_24      , v);break;
	case 0x602      : S94_SetGenDevACK( SUR_ONOFF, v);break;

	//
	//
	//

	case 0           : Set_SB_Mixer ( SB_MASTER   , v);
					   break;

	case 1           : Set_SB_Mixer ( SB_WAV      , v);break;
	case 2           : Set_SB_Mixer ( SB_FM       , v);break;
	case 3           : Set_SB_Mixer ( SB_CD       , v);break;
	case 4           : Set_SB_Mixer ( SB_LINE     , v);break;
	case 5           : Set_SB_Mixer ( SB_MIC      , v);break;

#ifdef ST_____97
	case 6           : S94_SetGenDev( GM_VOL      , v);break;

	case 7           : S94_SetGenDev( EQ_LBL      , v);
					   S94_SetGenDev( EQ_LBR      , v);break;

	case 8           : S94_SetGenDev( EQ_MLBL     , v);
					   S94_SetGenDev( EQ_MLBR     , v);break;

	case 9           : S94_SetGenDev( EQ_MHBL     , v);
					   S94_SetGenDev( EQ_MHBR     , v);break;

	case 10          : S94_SetGenDev( EQ_HBL      , v);
					   S94_SetGenDev( EQ_HBR      , v);break;

	case 11          : S94_SetGenDev( SUR_VOL     , v);break;
	case 12          : S94_SetGenDev( SUR_DEL     , v);break;
#else
	case 6           : Set_SB_Mixer ( SB_MIDI     , v);break;
	case 7           : Set_SB_Mixer ( SB_ECHO     , v);break;
#endif
	}
}


void MixerInit( char *path, int flag )
{

	if(flag)
		S94_ValueLoadAll( path );
#ifdef ST_____97
	else
		goto onlylev;
#endif
	//
	// SB Mixer ScrollBar
	//

	// master(AD1816) + audio gain(CS4218) + audio level(9407)
	Set_SB_Mixer ( SB_MASTER   , S94_Restore( SB_MASTER ) );

	Set_SB_Mixer ( SB_WAV      , S94_Restore( SB_WAV    ) );
	Set_SB_Mixer ( SB_FM       , S94_Restore( SB_FM     ) );
	Set_SB_Mixer ( SB_CD       , S94_Restore( SB_CD     ) );
	Set_SB_Mixer ( SB_LINE     , S94_Restore( SB_LINE   ) );
	Set_SB_Mixer ( SB_MIC      , S94_Restore( SB_MIC    ) );

#ifndef ST_____97
	Set_SB_Mixer ( SB_MIDI     , S94_Restore( SB_MIDI   ) );
	Set_SB_Mixer ( SB_ECHO     , S94_Restore( SB_ECHO   ) );
#endif

#ifdef ST_____97

	//
	// Absolute
	//

	S94_UART();

	S94_SetGenDevACK( EQU_TYPE    , 0 );
	S94_SetGenDevACK( AUD_ONOFF   , 0x7f );
	S94_SetGenDevACK( ECH_ONOFF   , 0x7f );
	S94_SetGenDevACK( CHR_ONOFF   , S94_Restore( CHR_ONOFF ) );
	S94_SetGenDevACK( REV_ONOFF	  , S94_Restore( REV_ONOFF ) );
	S94_SetGenDevACK( SUR_ONOFF	  , S94_Restore( SUR_ONOFF ) );


onlylev:

	S94_SetGenDev( GMREV_SEND  , S94_Restore( GMREV_SEND ) );
	S94_SetGenDev( GMCHR_SEND  , S94_Restore( GMCHR_SEND ) );

	S94_SetGenDev( GM_POST     , 0x7f );
	S94_SetGenDev( AUDECH_POST , 0x7f );
	S94_SetGenDev( EFF_POST    , 0x7f );

	S94_SetGenDev( AUD_SEL     , 0x7f);
	S94_SetGenDev( AUDL_PAN    , 0x0);
	S94_SetGenDev( AUDR_PAN    , 0x7f);
	S94_SetGenDev( AUD_GAINL   , 0);
	S94_SetGenDev( AUD_GAINR   , 0);
	S94_SetGenDev( AUDL_VOL    , 0xff );
	S94_SetGenDev( AUDR_VOL    , 0xff );

	//
	// Menu
	//

	S94_SetGenDev( EQF_LB      , S94_Restore( EQF_LB ) );
	S94_SetGenDev( EQF_MLB     , S94_Restore( EQF_MLB ) );
	S94_SetGenDev( EQF_MHB     , S94_Restore( EQF_MHB ) );
	S94_SetGenDev( EQF_HB      , S94_Restore( EQF_HB ) );

	S94_SetGenDev( ECH_LEV     , S94_Restore( ECH_LEV ) );
	S94_SetGenDev( ECH_TIM     , S94_Restore( ECH_TIM ) );
	S94_SetGenDev( ECH_FEED    , S94_Restore( ECH_FEED ) );

	S94_SetGenDev( REV_TYPE    , S94_Restore( REV_TYPE ) );
	S94_SetGenDev( CHR_TYPE    , S94_Restore( CHR_TYPE ) );

	S94_SetGenDev( REV_VOL     , S94_Restore( REV_VOL ) );
	S94_SetGenDev( CHR_VOL     , S94_Restore( CHR_VOL ) );

	S94_SetGenDev( REV_TIME    , S94_Restore( REV_TIME  ) );
	S94_SetGenDev( REV_FEED    , S94_Restore( REV_FEED  ) );

	S94_SetGenDev( CHR_DEL     , S94_Restore( CHR_DEL   ) );
	S94_SetGenDev( CHR_FEED    , S94_Restore( CHR_FEED  ) );
	S94_SetGenDev( CHR_RATE    , S94_Restore( CHR_RATE  ) );
	S94_SetGenDev( CHR_DEPTH   , S94_Restore( CHR_DEPTH ) );

	S94_SetGenDev( SUR_INP     , S94_Restore( SUR_INP ) );
	S94_SetGenDev( SUR_24      , S94_Restore( SUR_24  ) );

	//
	// Mixer ScrollBar
	//

	S94_SetGenDev( GM_VOL      , S94_Restore( GM_VOL ) );

	S94_SetGenDev( AUDREV_SEND , S94_Restore( AUDREV_SEND ) );
	S94_SetGenDev( AUDCHR_SEND , S94_Restore( AUDCHR_SEND ) );

	S94_SetGenDev( EQ_LBL      , S94_Restore( EQ_LBL ) );
	S94_SetGenDev( EQ_LBR      , S94_Restore( EQ_LBR ) );

	S94_SetGenDev( EQ_MLBL     , S94_Restore( EQ_MLBL ) );
	S94_SetGenDev( EQ_MLBR     , S94_Restore( EQ_MLBR ) );

	S94_SetGenDev( EQ_MHBL     , S94_Restore( EQ_MHBL ) );
	S94_SetGenDev( EQ_MHBR     , S94_Restore( EQ_MHBR ) );

	S94_SetGenDev( EQ_HBL      , S94_Restore( EQ_HBL ) );
	S94_SetGenDev( EQ_HBR      , S94_Restore( EQ_HBR ) );

	S94_SetGenDev( SUR_VOL     , S94_Restore( SUR_VOL ) );
	S94_SetGenDev( SUR_DEL     , S94_Restore( SUR_DEL ) );

	S94_UART();
#endif

}

void MixerClose( char *path )
{
	S94_ValueSaveAll( path );
}

int FindHwPort( void )
{
	int dx, cx, al;
	int sbIO;
	int mpuIO;

#ifdef ST_____97
	if( !(mpuIO=S94_Open()) )
		return 0;
#endif

	//
	// do with SB Pro
	//

	for( sbIO=0x220; sbIO<=0x240; sbIO+=0x10)
	{
		dx = sbIO+6;

		outp ( dx, 1 );
		inp ( dx );
		inp ( dx );
		inp ( dx );
		inp ( dx );
		outp ( dx, 0 );

		dx += 8;
		cx=100;
		do
		{
			al = inp ( dx );
			if( al & 0x80 )
			{
				al = inp ( dx-4 );
				if( al== 0xAA )
				{
					SB_SetPort( sbIO );
					goto loopout;
				}
			}

		}while( --cx );
	}

loopout:

	if( sbIO>0x240 )
	{
		printf("\nSB port not found in 220-240");
		return 0 ;
	}

#ifdef ST_____97
	printf("\nsbIO:%x mpuIO:%x\n", sbIO, mpuIO );
#else
	printf("\nsbIO:%x\n", sbIO );
	AdInit();
#endif

	return 1;
}